Method and apparatus for storing routes for groups of related net configurations

ABSTRACT

Some embodiments of the invention provide a method that pre-computes routes for groups of related net configurations. These routes are used by a router that uses a set of partitioning lines to partition a region of a design layout into a plurality of sub-regions. The method identifies groups of related sub-region configurations. For each group, the method stores a base set of routes. For each configuration in each group, the method also stores an indicia that specifies how to obtain a related set of routes for the particular configuration from the base set of routes stored for the configuration&#39;s group.

CLAIM OF BENEFIT TO PRIOR APPLICATIONS

This patent application claims the benefit of the earlier-filed U.S.Provisional Patent Application entitled “Routing Method and Apparatus”,having Ser. No. 60/314,580, and filed Aug. 23, 2001; and U.S.Provisional Patent Application entitled “Routing Method and Apparatus”,having Ser. No. 60/337,504, and filed Dec. 6, 2001. This patentapplication is also a continuation-in-part application of U.S. patentapplication Ser. No. 10/013,816, filed Oct. 19, 2001.

FIELD OF THE INVENTION

The invention is directed towards method and apparatus for storingroutes for groups of related net configurations.

BACKGROUND OF THE INVENTION

An integrated circuit (“IC”) is a device that includes many electroniccomponents (e.g., transistors, resistors, diodes, etc.). Thesecomponents are often interconnected to form multiple circuit components(e.g., gates, cells, memory units, arithmetic units, controllers,decoders, etc.) on the IC. The electronic and circuit components of IC'sare jointly referred to below as “components.”

An IC also includes multiple layers of wiring (“wiring layers”) thatinterconnect its electronic and circuit components. For instance, manyIC's are currently fabricated with metal or polysilicon wiring layers(collectively referred to below as “metal layers”) that interconnect itselectronic and circuit components. One common fabrication model usesfive metal layers. In theory, the wiring on the metal layers can beall-angle wiring (i.e., the wiring can be in any arbitrary direction).Such all-angle wiring is commonly referred to as Euclidean wiring. Inpractice, however, each metal layer typically has a preferred wiringdirection, and the preferred direction alternates between successivemetal layers. Many IC's use the Manhattan wiring model, which specifiesalternating layers of preferred-direction horizontal and verticalwiring. In this wiring model, the majority of the wires can only make90° turns. However, occasional diagonal jogs are sometimes allowed onthe preferred horizontal and vertical layers.

Design engineers design IC's by transforming circuit description of theIC's into geometric descriptions, called layouts. To create layouts,design engineers typically use electronic design automation (“EDA”)applications. These applications provide sets of computer-based toolsfor creating, editing, and analyzing IC design layouts.

EDA applications create layouts by using geometric shapes that representdifferent materials and devices on IC's. For instance, EDA toolscommonly use rectangular lines to represent the wire segments thatinterconnect the IC components. These tools also represent electronicand circuit IC components as geometric objects with varying shapes andsizes. For the sake of simplifying the discussion, these geometricobjects are shown as rectangular blocks in this document.

Also, in this document, the phrase “circuit module” refers to thegeometric representation of an electronic or circuit IC component by anEDA application. EDA applications typically illustrate circuit moduleswith pins on their sides. These pins connect to the interconnect lines.

A net is typically defined as a collection of pins that need to beelectrically connected. A list of all or some of the nets in a layout isreferred to as a net list. In other words, a net list specifies a groupof nets, which, in turn, specify the interconnections between a set ofpins.

FIG. 1 illustrates an example of an IC layout 100. This layout includesfive circuit modules 105, 110, 115, 120, and 125 with pins 130-160. Fourinterconnect lines 165-180 connect these modules through their pins. Inaddition, three nets specify the interconnection between the pins.Specifically, pins 135, 145, and 160 define a three-pin net, while pins130 and 155, and pins 140 and 150 respectively define two two-pin nets.As shown in FIG. 1, a circuit module (such as 105) can have multiplepins on multiple nets.

The IC design process entails various operations. Some of thephysical-design operations that EDA applications commonly perform toobtain the IC layouts are: (1) circuit partitioning, which partitions acircuit if the circuit is too large for a single chip; (2) floorplanning, which finds the alignment and relative orientation of thecircuit modules; (3) placement, which determines more precisely thepositions of the circuit modules; (4) routing, which completes theinterconnects between the circuit modules; (5) compaction, whichcompresses the layout to decrease the total IC area; and (6)verification, which checks the layout to ensure that it meets design andfunctional requirements.

Routing is a key operation in the physical design cycle. It is generallydivided into two phases: global routing and detailed routing. For eachnet, global routing generates a “loose” route (also called path orrouting areas) for the interconnect lines that are to connect the pinsof the net. The “looseness” of a global route depends on the particularglobal router used. After global routes have been created, the detailedrouting creates specific individual routing paths for each net.

While some commercial global routers today might allow an occasionaldiagonal jog, these routers do not typically explore diagonal routingpaths consistently when they are specifying the routing geometries ofthe interconnect lines. This, in turn, increases the total wirelength(i.e., total length of interconnect lines) needed to connect the nets inthe layout. Therefore, there is a need for routing method and apparatusthat considers diagonal routing paths.

SUMMARY OF THE INVENTION

Some embodiments of the invention provide a method that pre-computesroutes for groups of related net configurations. These routes are usedby a router that uses a set of partitioning lines to partition a regionof a design layout into a plurality of sub-regions. The methodidentifies groups of related sub-region configurations. For each group,the method stores a base set of routes. For each configuration in eachgroup, the method also stores an indicia that specifies how to obtain arelated set of routes for the particular configuration from the base setof routes stored for the configuration's group.

BRIEF DESCRIPTION OF THE DRAWINGS

The novel features of the invention are set forth in the appendedclaims. However, for purpose of explanation, several embodiments of theinvention are set forth in the following figures.

FIG. 1 illustrates an example of an IC layout.

FIG. 2 illustrates an IC layout that utilizes horizontal, vertical, and45° diagonal interconnect lines.

FIG. 3 illustrates one manner of implementing an octagonal wiring model.

FIG. 4 presents a conceptual illustration of a recursive routing processperformed by some embodiments of the invention.

FIG. 5 illustrates a design region of an IC layout that has been dividedinto sixteen sub-regions.

FIGS. 6-8 illustrate three Steiner trees for a net illustrated in FIG.5.

FIG. 9 illustrates two congestion grids.

FIG. 10 illustrates edges defined by the congestion grids of FIG. 9.

FIG. 11 shows the diagonal edges of FIG. 10 slightly smaller.

FIG. 12 illustrates wiring paths across the edges of FIG. 10.

FIG. 13 illustrates a partitioning grid used by some embodiments.

FIG. 14 illustrates Manhattan and diagonal paths defined across edgescreated by the grid of FIG. 13.

FIG. 15 illustrates a length grid that decomposes each congestion-gridchild slots of the grid of FIG. 13 into 4 slots, while

FIG. 16 illustrates a length grid that decomposes each of these childslots into 16 slots.

FIG. 17 illustrates that the partitioning of FIG. 15 creates 6 paths forrouting between the resulting 4 slots in each congestion-graph childslot, while

FIG. 18 illustrates that the partitioning of FIG. 16 creates 42 pathsfor routing between the resulting 16 slots of each congestion-graphchild slot.

FIG. 19 illustrates a process for adaptively selecting the wiring model,as well as the congestion and/or partitioning grids.

FIGS. 20 and 21 illustrate how some embodiments calculate the length ofan interconnect line connecting two nodes of a tree.

FIG. 22 illustrates a process that constructs one or more optimalSteiner trees for each possible net configuration with respect to apartitioning grid, and stores the trees and their attributes.

FIG. 23 pictorially illustrates sixteen tree nodes for sixteen slotscreated by a 4-by-4 partitioning grid.

FIG. 24 illustrates a process for identifying potential Steiner nodes.

FIGS. 25A and 25B illustrate a process for that constructing one or moreminimum spanning trees (MST's) and computing each MST's length for nodeconfigurations with two or more nodes.

FIG. 26 illustrates a process that calculates the routing-pathinformation and the path-usage probabilities.

FIGS. 27 and 28 respectively illustrate examples of path-usage countsand path-usage probabilities for the Steiner trees of FIGS. 6-8.

FIG. 29 illustrates a compression technique for storing Steiner-treeroutes for sets of net configurations.

FIGS. 30 and 31 illustrate one technique for grouping nodeconfigurations.

FIG. 32 illustrates a binary-search tree (“BST”) used for sorting storedtrees.

FIG. 33 illustrates a process used to traverse the BST to determinewhether a tree was previously stored in the storage structure.

FIG. 34 illustrates a process that pre-tabulates routes and routeattributes for multiple wiring models.

FIG. 35A and FIG. 35B illustrate examples of closed and open nodeconfigurations.

FIG. 36 illustrates a process that pre-tabulates minimum closed trees.

FIG. 37 illustrates a process that, for an open node configuration,pre-tabulates related closed node configurations that do not haveantenna nodes.

FIG. 38 illustrates a process that identifies one or more Steiner-treeroutes for a net when the routes and closed node configurations arepre-tabulated according to the processes of FIGS. 36 and 37.

FIG. 39 illustrates the software architecture of a router of someembodiments of the invention.

FIG. 40 illustrates a design region that is recursively divided intosets of 16 sub-regions.

FIG. 41 illustrates the data structure for a net list.

FIG. 42 illustrates a dbNet data structure.

FIG. 43 illustrates a simple pin data structure.

FIG. 44 illustrates a path data structure.

FIG. 45 illustrates a slot-net data structure.

FIG. 46 presents a graph that conceptually illustrates the hierarchy ofslots defined by the router.

FIG. 47 presents a slot data structure.

FIG. 48 illustrates a circuit module data structure.

FIGS. 49-51 illustrate a process that is performed by an initializer ofthe router of FIG. 39.

FIG. 52 illustrates a process performed by a slot manager of the routerof FIG. 39.

FIG. 53 illustrates a process performed by a solver of the router ofFIG. 39.

FIGS. 54 and 55 illustrate one manner for predicting the congestion ofthe paths.

FIG. 56 illustrates a process for identifying routes for each netconfiguration and generating detour possibilities by adding fake pins tothe net configurations.

FIGS. 57 and 58 provide examples of how sub-optimal detour routes aregenerated by adding one or two fake pin configurations.

FIG. 59 illustrates another technique for identifying additional routesfor a net configuration.

FIG. 60 illustrates a process that identifies additional routes for anet configuration.

FIG. 61 illustrates one way for propagating a horizontal or verticalpath between the current slot's child slots down into the slots of thechild slots.

FIGS. 62 and 63 illustrate two different ways for modeling thepropagation of a 45° diagonal path into the lower level child slots.

FIG. 64 illustrates a process for calculating the cost of each route interms of three component costs.

FIG. 65 illustrates one example of a propagation possibility of a path.

FIGS. 66 and 67 present two examples that conceptually illustrate onemanner of counting the number of vias.

FIGS. 68-70 illustrate three processes that work together to compute thenumber of vias in a route.

FIGS. 71 and 72 illustrate the need for sharing constraints at the Gcelllevel.

FIG. 73 illustrates a diagonal pair constraint.

FIG. 74 illustrates a mixed triplet constraint.

FIG. 75 illustrates a diagonal triplet constraint.

FIG. 76 illustrates a process that an ILP propagator performs in someembodiments.

FIGS. 77 and 78 illustrate one manner of estimating the availability ofthe propagations.

FIGS. 79 and 80 illustrate one manner of enumerating and costing thepropagations.

FIG. 81 illustrates a process for performing follow-up propagation forthe current slot when the current slot is below the top-level slot butabove the leaf-level slot.

FIG. 82 illustrates a path from a follow-up path list that ispropagated.

FIG. 83 illustrates one a sequential-propagation process that is used insome embodiments.

FIG. 84 presents a computer system used to implement some embodiments ofthe invention.

DETAILED DESCRIPTION OF THE INVENTION

In the following description, numerous details are set forth for purposeof explanation. However, one of ordinary skill in the art will realizethat the invention may be practiced without the use of these specificdetails. In other instances, well-known structures and devices are shownin block diagram form in order not to obscure the description of theinvention with unnecessary detail.

Several embodiments of the invention's routing method and apparatus aredescribed below. However, before discussing these embodiments, severaldiagonal wiring architectures that can be used with these embodimentsare described in Section I.

I. Diagonal Wiring Architecture

Different embodiments of the invention can be used with different wiringmodels. For instance, some embodiments are used with wiring models thatinclude diagonal, horizontal, and vertical interconnect wires. In thediscussion below, interconnect wires are also referred to asinterconnects or interconnect lines. Also, as used in this document, aninterconnect line is “diagonal” if it forms an angle other than zero orninety degrees with respect to the layout boundary. On the other hand,an interconnect line is “horizontal” or “vertical” if it forms an angleof 0° or 90° with respect to one of the sides of the layout (e.g., formsan angle of 0° or 90° with respect to the width of the layout).

FIG. 2 illustrates an IC layout 200 that utilizes horizontal, vertical,and 45° diagonal interconnect lines. In this figure, the horizontallines 205 are the lines that are parallel (i.e., are at 0°) to thex-axis, which is defined to be parallel to the width 210 of the layout.The vertical lines 215 are parallel to the y-axis, which is defined tobe parallel to the height 220 of the layout. In other words, thevertical interconnect lines 215 are perpendicular (i.e., are at 90°) tothe width of the IC layout. In addition, one set 225 of diagonal linesare at +45° with respect to the width of the IC layout, while anotherset 230 are at −45° with respect to the width of the IC layout. In thisdocument, the phrase “octagonal wiring model” is used to refer to awiring model that includes horizontal, vertical, and 45° diagonalinterconnect lines.

FIG. 3 illustrates one manner of implementing the octagonal wiringmodel. The wire model illustrated in this figure uses the notion ofhaving one preferred-wiring direction per layer. Specifically, FIG. 3illustrates five wire layers with each layer having its own preferreddirection. The first three layers 305-315 are Manhattan layers. In otherwords, the preferred direction for the interconnect lines in theselayers is either the horizontal direction or the vertical direction. Thepreferred wiring direction in these three layers typically alternates sothat no two consecutive layers have the same preferred wiring direction.However, in some cases, the wiring in consecutive layers is in the samedirection.

The next two layers 320 and 325 are diagonal layers. The preferreddirections for the interconnect lines in the diagonal layers are ±45°.Also, as in the first three layers, the wiring directions in the fourthand fifth layer are typically orthogonal (i.e., one layer is +45° andthe other is −45°), although they do not have to be.

Several embodiments are described below with reference to the octagonalwiring model illustrated in FIG. 3. However, one of ordinary skill willunderstand that the invention can be used with any wiring model. Forinstance, the invention can be used with wiring architectures that arestrictly diagonal (i.e., wiring architectures that do not havehorizontal and vertical direction wiring).

Also, some embodiments are used with non-45° diagonal wiring. Forexample, some embodiments are used with wiring models that utilizehorizontal, vertical and ±120° diagonal interconnect lines. In addition,some embodiments are used with wire models that do not specify apreferred direction for some or all the wire layers. For instance, someembodiments use an octagonal wiring model that allows horizontal,vertical, and 45° lines to exist on all wire layers.

II. Conceptual Flow

FIG. 4 presents a conceptual illustration of a recursive routing processperformed by some embodiments of the invention. This routing processhierarchically defines routes for nets within a design region (alsocalled a slot) of an IC layout. This region can be the entire IC layout,or a portion of this layout. Likewise, the IC layout can be a layout forthe entire integrated-circuit chip or chips, or it can be a layout for ablock (i.e., a portion) of an integrated-circuit chip.

The process initially defines (at 405) a partitioning grid that dividesthe IC region into several sub-regions. In the discussion below, thepartitioned region is also referred to as the current slot, and thesub-regions resulting from the partitioning are also referred to as thecurrent slot's child slots.

In some embodiments, the partitioning grid is formed by intersecting cutlines. In some of these embodiments, the intersecting partitioning linesare N horizontal and M vertical lines that divide the IC region into(N+1)(M+1) sub-regions, where N and M can equal any integer. Forinstance, these horizontal and vertical lines divide the received ICregion into (1) four child slots when N and M equal 1, (2) nine childslots when N and M equal 2, (3) sixteen child slots when N and M equal3, or (4) twenty child slots when either N or M equals 4 and the otherequals 5.

FIG. 5 illustrates a design region 500 that has been divided intosixteen sub-regions (i.e., into child slots 0-15) by sets of threehorizontal and vertical partitioning lines. This figure also shows a net505 that includes five circuit modules 510, 515, 520, 525, and 530,which fall into four of the sixteen sub-regions. These four sub-regionsare slots 0, 1, 7, and 8.

Each net within the partitioned region (i.e., within the current slot)has one or more actual or virtual pins in the sub-regions defined by thepartitioning grid. A net's actual pins are pins of circuit modules inthe design region, whereas the net's virtual pins are artificial pinsthat are set to account for the propagation of higher level routes intolower level child slots, as further described below. For each net, theset of sub-regions that contain that net's actual or virtual pinsrepresents the net's configuration with respect to the partitioninggrid.

For each particular net within the partitioned region, the process 400uses (at 410) the net's configuration to identify one or more routes(also called routing graphs or connection graphs) for the net. Eachroute of a net provides a set of interconnect lines that connects thechild slots (i.e., the sub-regions) that contain the net's pins.

To model each net's configuration with respect to the grid, each childslot that contains one or more of the net's pins is treated as a node(also called a vertex or point) of the routing graph. The nodes of thegraph are then connected by edges (also called lines). According to someembodiments, the routing graph can have edges that are completely orpartially diagonal.

Different embodiments use different types of graphs to define theinterconnect routes. In the embodiments described below, trees (e.g.,Steiner trees) are used as the routing graphs that connect the childslots containing the related net pins. FIGS. 6-8 illustrate threeoptimal Steiner trees 605, 705, and 805 for the net 505 in FIG. 5. TheseSteiner trees all have the same length. One of these trees (605) has aSteiner node (620). In addition, each of these trees has at least oneedge that is at least partially diagonal. In these examples, the routeruses the octagonal wiring model and therefore the diagonal edges are at45° degrees with respect to the layout boundary.

Before process 400 starts, some embodiments pre-compute and store routesfor different configuration of child slots in a data storage. Atrun-time, the router in these embodiments identifies (at 410) some orall of the routes for a net by (1) identifying the configuration of eachnet with respect to the partitioning grid, and (2) retrieving from thedata storage the routes for the identified-configurations. Such anapproach frees the router from having to construct in real-time routesfor each net configuration. One such approach is described below inSection V.

Other embodiments, on the other hand, use net configurations to generateroutes in run time. Yet other embodiments use net configurations toretrieve and generate routes. For instance, some embodiments use netconfigurations to retrieve pre-tabulated routes for certain nets whilegenerating routes for other nets. One such approach is described belowin Section V.

In some embodiments, the pre-tabulated or generated routes are optimalroutes. Some of these embodiments also have the router identifysub-optimal routes for each net configuration in the layout, in order toincrease the number of possible solutions for each net. One suchapproach is described below in Section VI.

For each net, the process 400 selects (at 415) one of the routesidentified for the net as the net's route at the current recursionlevel. The process selects the routes that optimize certain objectives,such as reducing wirelength and congestion. When the current slot'schild slots are to be partitioned to define smaller child slots, theprocess 400 then determines (at 420) the propagation of the selectedroutes into the smaller child slots. At this stage, the process mightalso add virtual pins to certain nets to account for such propagation.

Finally, when the child slots defined at 405 are not the slots resultingfrom the last recursion operation, the process 400 recursively repeatsfor each child slot defined at 405. By recursively repeating for eachdefined child slot, the process 400 defines more and more detailedroutes for the nets in the current region. In other words, thisrecursive process 400 defines the routes in a hierarchical manner, wherethe process defines more detailed routes as the levels of the recursionhierarchy increase.

Some embodiments use different shaped partitioning grids for differentlevels in the recursion process. The embodiments described below,however, use same shaped partitioning grids for all the recursionlevels. At each recursion level, these embodiments simply adjust thecoordinates of the partitioning grid to match the coordinates of the ICregion at that recursion level. Using the same shaped partitioning gridsfor all the recursion levels has several advantages. For instance, theprocess can re-use the same set of pre-tabulated information for alllevels of the recursion process.

III. Multiple Grids

Some embodiments use one or more grids in addition to the partitioninggrid.

A. Multiple Congestion Grids.

Some embodiments use multiple congestion grids as the conceptual modelfor quantifying the capacity, and measuring the congestion, of routingpaths between the sub-regions that are defined by the partitioning grid.FIG. 9 illustrates two such congestion grids. Some embodiments describedbelow use these two grids in conjunction with the octagonal wiring modelillustrated in FIG. 3.

In FIG. 9, the two grids are: (1) grid 905, which is formed by 3horizontal and 3 vertical lines, and (2) grid 910, which is formed byseven +45° diagonal lines and seven −45° diagonal lines. Grid 905 isused to specify the capacity and measure the congestion of horizontaland vertical routing paths, while grid 910 is used to specify thecapacity and measure the congestion of diagonal routing paths.

Specifically, as shown in FIG. 10, the grid 905 defines 12 verticaledges (E0-E11) and 12 horizontal edges (E12-E23), while the grid 910defines 9 −45° edges (E24, E26, E28, E30, E32, E34, E36, E38, E40) and 9+45° edges (E25, E27, E29, E31, E33, E35, E37, E39, E41). In FIG. 10,the diagonal edges are shown to have endpoints, in order to simplify theidentification of these edges as they abut each other.

As shown in FIG. 10, each diagonal edge traverses the distance betweenthe centers of two sub-regions that are defined by the first grid andthat are at diagonally adjacent positions with respect to each other. Inother words, each diagonal edge connects the centers of two sub-regionsthat are aligned diagonally such that they abut at only one of theircorners. FIG. 11 shows the diagonal edges slightly smaller, in order tosimplify the appearance of these edges.

In some embodiments, grids 905 and 910 are also used to define routingpaths between the child slots of a partitioned region. Specifically,orthogonal to each edge defined by grids 905 and 910 is a routing paththat can be used by a routing tree to connect the abutting slots (i.e.,the abutting sub-regions). For instance, FIG. 12 illustrates 42 wiringpaths across the 42 edges of FIG. 10. Horizontal paths P0-P11 aredefined across vertical edges E0-E11, vertical paths P12-P23 are definedacross horizontal edges E12-E23 that vertical routing paths willintersect, +45° paths P24, P26, P28, P30, P32, P34, P36, P38, P40 aredefined across −45° edges E24, E26, E28, E30, E32, E34, E36, E38, E40,and −45° paths P25, P27, P29, P31, P33, P35, P37, P39, P41 are definedacross +45° edges E25, E27, E29, E31, E33, E35, E37, E39, E41.

The congestion problem can be expressed and analyzed in terms of eitherthe edge capacities or the path capacities, as these two sets ofcapacities are intertwined. The processes described below analyze thecapacity issue in terms of the path capacities. One of ordinary skillwill realize, however, that analogous processes can be used to analyzethe capacity issue in terms of edge capacities.

As further described below, some embodiments derive the capacity of eachpath from the size of the edge that the path intersects. For instance,some embodiments calculate the capacity of each particular path bydividing the size of the corresponding orthogonal edge (i.e., the sizeof the edge orthogonal to the particular path) with the pitch of metallayer corresponding to the particular path. Some embodiments define thepitch of a metal layer as the line-to-via pitch. Some embodiments definethe line-to-via pitch as the minimum required distance betweeninterconnect lines on that metal layer, plus ½ the width of the line,plus ½ the width of the via including the metal overlap.

In some embodiments, the capacities of the diagonal paths differ fromthe capacities of the Manhattan paths. This can be due to the differingsize of the edges that are orthogonal to the diagonal and Manhattanpaths. It can also be due to the pitch of the diagonal lines beingdifferent from the pitch of the Manhattan lines. It can further be dueto the pitch of one layer being different than the pitch of anotherlayer. For example, in some embodiments, the capacities of the −45°diagonal paths differ from the capacities of the 45° diagonal paths,when the pitch of the −45° metal layer differs from the pitch of the 45°metal layer.

In FIG. 9, the grid 905 is the same as the partitioning grid illustratedin FIG. 5. However, one of ordinary skill will appreciate that bothcongestion grids can differ from the partitioning grid. In addition,even though FIG. 9 illustrates two congestion grids 905 and 910 for someembodiments, one of ordinary skill will appreciate that other multi-gridarrangements can be used by other embodiments.

Some embodiments generally define the number and structure of congestiongrids based on the number of wiring directions and wiring levels of thewiring model used to design the design layout and/or the IC. Forinstance, some embodiments use a wiring model that allows routing inhorizontal, vertical, +120° diagonal, and −120° diagonal directions. Forsuch a wiring model, two congestion grids can be used. Like grid 905,the first grid could be formed by intersecting horizontal and verticallines, in order to define the capacity and measure the congestion ofvertical and horizontal routing paths. The second grid could be used todefine the capacity and measure the congestion of ±120° diagonal routingpaths. This second grid could be similar to the first grid, except thatthe axis of the second grid would be rotated 120° with respect to theaxis of the first grid. In other words, this second grid could be formedby a number of intersecting ±30° lines.

B. Congestion and Length Grids.

Some embodiments use (1) a first grid to partition an IC region andmeasure congestion in this region, and (2) a second grid to measurewirelength costs in the region. FIGS. 13-18 illustrate several suchembodiments. These embodiments use the wiring model that includeshorizontal, vertical, and ±45° interconnect lines. One of ordinary skillwill understand that other embodiments use other wiring models (such asones that use ±120° lines).

FIG. 13 illustrates a first grid 1305 that some embodiments use topartition an IC region into 16 sub-regions. This grid also defines 24edges E0-E23 that are used to measure congestion of Manhattan andnon-Manhattan interconnect lines in the region. As shown in FIG. 14, 24Manhattan paths P0-P23 and 48 diagonal paths P24-P71 are defined acrossthese 24 edges E0-E23. Each path represents one or more tracks of wiringin the path's direction across the path's corresponding edge.

Vertical edges E0-E11 are used to measure congestion of wires (i.e., ofinterconnect lines) that cross these vertical edges in the direction ofhorizontal paths P0-P11 and ±45° diagonal paths P24-P29, P38-P43,P52-P57, and P66-P71. Similarly, horizontal edges E12-E23 are used tomeasure congestion of wires that cross these horizontal edges in thedirection of vertical paths P12-P23 and ±45° diagonal paths P30-P37,P44-P51, and P58-P65.

Some embodiments define each route in terms of the paths P0-P71. PathsP0-P71 are also used to measure congestion in the IC region. In someembodiments, the capacity along the diagonal paths P24-P71 is less thanthe capacity along the Manhattan paths P0-P3. For instance, someembodiments specify that (1) each Manhattan path represents 8-tracks ofwires at the lowest-level child slot (i.e., at the Gcell level), and (2)each diagonal path represents 5-tracks of wires at the Gcell level whenthe diagonal and Manhattan layers have the same pitch. Some embodimentsspecify less than 5-tracks for a diagonal path at the Gcell level, whenthe pitch of the diagonal path's layer is greater than the pitch of aManhattan path layer.

As mentioned above, some embodiments use a second grid to measure thewirelength costs of the routes in the region. This length griddecomposes each congestion-grid child slot into smaller slots. Forinstance, FIG. 15 illustrates a length grid that decomposes each of the16 congestion-grid child slots of grid 1305 into 4 slots, while FIG. 16illustrates a length grid that decomposes each of the 16 congestion-gridchild slots of grid 1305 into 16 slots. Other embodiments use othertypes of grids (e.g., a 3×5 grid) to decompose the congestion-grid childslots.

FIG. 17 illustrates that the 2×2 partitioning of FIG. 15 define 6 pathsfor routing between the resulting 4 slots in each congestion-graph childslot, while FIG. 18 illustrates that the 4×4 partitioning of FIG. 16defines 42 paths for routing between the resulting 16 slots of eachcongestion-graph child slot. In addition, each type of partitioningdefines several paths between the length-grid slots of adjacentcongestion-grid child slots. These paths will be further describedbelow.

The length grid can be used to estimate the wirelength cost of eachnet's route by identifying one or more segments that traverse thelength-grid paths to connect all of the net's pins. In other words, fora net's route, an estimated wirelength cost is the length of a set oflength-grid paths that (1) connect the length-grid slots that containthe net's pins, and (2) cross the same congestion-graph edges in thesame direction as the congestion-graph paths used by the net's route.The wirelength cost of a set of length-grid paths includes the cost ofthe interior paths (i.e., length-grid paths inside congestion-gridslots) that connect the length-grid slots containing the net's pins,plus the cost of the periphery length-grid path(s) that cross theincident congestion-graph edge(s).

In some embodiments, propagating a congestion-grid path to a peripherylength-grid path (i.e., a length-grid path between congestion gridslots) might require the setting of a virtual pin in the net's pinconfiguration with respect to the length grid. Accordingly, the interiorlength-grid paths connect the length-grid slots that contain actual orvirtual pins of the net. Also, as mentioned above, the peripherylength-grid paths (i.e., the length-grid paths across congestion-graphedges) cross the congestion-graph edges in the same direction as thecongestion-graph paths used by the net's route.

FIGS. 17 and 18 illustrate diagonal length-grid paths between thelength-grid slots of diagonally-adjacent congestion-grid child slots. Inthese figures, such diagonal length-grid paths are circled with dashedlines. Some embodiments define such diagonal length-grid paths whileothers do not.

Also, some of the embodiments that have diagonal length-grid pathsbetween diagonally-adjacent congestion-grid child slots use a particularconvention to correlate these diagonal length-grid paths with thediagonal congestion-graph paths. In some embodiments, such −45°length-grid paths are tied either to their corresponding bottom and leftcongestion-graph paths or to their corresponding top and rightcongestion-graph paths. For instance, when a −45° length grid path isused between congestion-graph child slots 9 and 12, some embodimentsincrement the path-usage of paths 53 and 59 by one, while otherembodiments increment the path-usage of paths 61 and 67 by one. (Paths53, 59, 61, and 67 are illustrated in FIG. 14.)

Analogously, some embodiments tie +45° length-grid paths either to theircorresponding bottom and right congestion-graph paths or to theircorresponding top and left congestion-graph paths. For instance, when a+45° length grid path is used between congestion-graph child slots 8 and13, some embodiments increment the path-usage of paths 58 and 66 by one,while other embodiments increment the path-usage of paths 52 and 60 byone. (Paths 52, 58, 60, and 66 are illustrated in FIG. 14.)

Alternatively, some embodiments tie diagonal length-grid paths betweendiagonally-adjacent congestion-grid child slots to only one of the foursurrounding congestion-graph paths, and assign one additional track tothe capacity of this congestion-graph path. Some embodiments tie a −45°length-grid path to its corresponding left congestion-graph path, andtie +45° length-grid path to its corresponding right congestion-graphpath. Under this approach, some embodiments associate the −45° lengthgrid path between congestion-graph child slots 9 and 12 with path 59,and assign a capacity of 6 to path 59 at the Gcell level while assigninga capacity of 5 to path 53.

Yet other embodiments do not correlate the diagonal length-grid pathsbetween congestion-graph child slots with the diagonal congestion-graphpaths P0-P71. Instead, these embodiments define 18 additional diagonalcongestion-graph paths between the 18 pairs of diagonally-adjacentcongestion graph slots. Each of these 18 additional congestion pathscorresponds to a particular length-grid path. Also, at the Gcell level,some embodiments define each of these 18 additional paths to be 1-trackwide.

Different embodiments use the congestion and length grids differently.For instance, some embodiments identify routes based on netconfigurations with respect to the congestion grid 1305, and then usethe length and congestion grids to compute wirelength and congestioncosts of the identified routes. Other embodiments successively expand aroute for a net through the length grid. For each expansion or potentialexpansion, these embodiments use the length grid to cost the expansionor potential expansion. If the expansion or potential expansion crossesone of the congestion grid edges, these embodiments factor a congestioncost for it. Also, as mentioned above, some embodiments only define eachroute eventually in terms of the paths P0-P71 defined across thecongestion grid, while others do not.

IV. Adaptive Selection of Wiring Model

Some embodiments adaptively select their wiring model based on theaspect ratio (height-to-width ratio) of the design region (i.e., theregion being designed). FIG. 19 illustrates a process 1900 for makingsuch an adaptive selection. This process is typically performed beforedefining the partitioning grid at 405 of process 400. In someembodiments, the designer performs some or all operations of thisprocess manually, while in other embodiments the router performs some orall the operations of this process in an automated fashion.

This process initially identifies (at 1905) the aspect ratio of thedesign region. To identify the aspect ratio, the process can calculatethis ratio based on the dimensions of the design region, or it canretrieve a pre-tabulated aspect ratio for the design block. The processnext selects (at 1910) a wiring model based on the identified aspectratio. In some embodiments, the process 1900 then adaptively selects (at1915) the partitioning and/or congestion grids. In some embodiments, theprocess adaptively selects the partitioning and/or congestion gridsbased on the wiring model.

Adaptive selection of the wiring model allows a design region to berouted with a view to achieving certain design objectives (e.g.,minimizing wirelength and congestion). For instance, when designing acircuit block that has a relatively large aspect ratio (i.e., a circuitblock that is tall and skinny), some embodiments adaptively select awiring model that allows routing in horizontal, vertical, ±120° diagonaldirections, because such a wiring model reduces wirelength andcongestion for routing such a circuit block. For such a wiring model,some embodiments use a first congestion grid (like grid 905 of FIG. 9)that is formed by intersecting horizontal and vertical lines, and asecond congestion grid that is formed by intersecting ±30° lines, asdescribed above.

Also, for such a wiring model and IC region, some embodiments use apartitioning grid that divides the IC region into smaller regions thathave large aspect ratio. In some such embodiments, diagonally-adjacentpartitioned regions have their centers offset by 120° from each other,so that their centers can be connected by 120° diagonal lines.

Numerous other wiring models can be used for a design block with a largeaspect ratio. For instance, another wiring model would be one that wouldallow routing in the horizontal, vertical, ±45° diagonal, and ±120diagonal directions. For such a wiring model, some embodiments might usethe following three congestion grids: (1) a first grid that is forhorizontal and vertical paths and that is formed (like grid 905 of FIG.9) by intersecting horizontal and vertical lines, (2) a second grid thatis for ±120° paths and that is formed by intersecting ±30° lines, and(3) a third grid that is for ±45° paths and that is formed byintersecting ±45° diagonal lines.

Similarly, numerous wiring models can be used for a design block with asmall aspect ratio (i.e., a block that is short and wide). For instance,some embodiments might adaptively select for such a block a wiring modelthat allows routing in horizontal, vertical, ±30° diagonal directions.For such a wiring model, some embodiments use the following twocongestion grids (1) a first grid that is for horizontal and verticalpaths and that is formed (like grid 905 of FIG. 9) by intersectinghorizontal and vertical lines, and (2) a second grid that is for ±30°diagonal paths and that is formed by intersecting ±120° lines.

For such a wiring model and congestion grid, some embodiments use apartitioning grid that divides the IC region into smaller regions thathave small aspect ratio. In some such embodiments, diagonally-adjacentpartitioned regions have their centers offset by 30° from each other, sothat their centers can be connected by 30° diagonal lines.

Another wiring model for such a block would be one that would allowrouting in the horizontal, vertical, ±45° diagonal, and ±30° diagonaldirections. For such a wiring model, some embodiments use the followingthree congestion grids: (1) a first grid that is for horizontal andvertical paths and that is formed (like grid 905 of FIG. 9) byintersecting horizontal and vertical lines, (2) a second grid that isfor ±30° diagonal paths and that is formed by intersecting ±120° lines,and (3) a third grid that is for ±45° diagonal paths and that is formed(like grid 910 of FIG. 9) by intersecting ±45° lines.

When the design block is square, some embodiments might select aperfectly symmetrical wiring model, such as the five-layer octagonalwiring model discussed above by reference to FIG. 3. However, in thissituation, other embodiments might select more complicated wiringmodels. For instance, some embodiments might select a nine-layer wiringmodel, which includes the first five layers illustrated in FIG. 3 plusanother four layers that are similar to layers 2-5 illustrated in FIG.3. One set of congestion grids for such a wiring model can include theabove-mentioned grids 905 and 910 for layers 2-5, and another two gridssimilar to grids 905 and 910 for layers 6-9.

Another complicated symmetrical wiring model that some embodiments mightuse is similar to the 9-layer model described above, except that thepreferred directions in the last four layers (i.e., layers 6-9) havebeen shifted by 22.5° in the same direction. This would result in awiring model that would provide 16-directions of routing from any givenpoint, where each routing-path direction is 22.5° from its neighboringrouting-path directions. One set of congestion grids for such a wiringmodel can include grids 905 and 910 mentioned above for layers 1-5, andanother two grids that are 22.5°-shifted versions of grids 905 and 910for layers 6-9.

V. Pre-Tabulating Routing Information

As mentioned above, some embodiments pre-compute and store routes fordifferent configuration of child slots in a storage structure. Atrun-time, the router in these embodiments identifies some or all of theroutes for a net by (1) identifying the configuration of each net withrespect to the partitioning grid, and (2) retrieving from the storagestructure the routes for the identified-configurations. One manner ofpre-tabulating Steiner-tree routes is described below by reference toFIGS. 20-34.

Other embodiments, on the other hand, use net configurations to generateroutes in real time. Yet other embodiments use net configurations toretrieve and generate routes. For instance, some embodiments use netconfigurations to retrieve pre-tabulated routes for certain nets and togenerate routes for other nets. One such approach is described below byreference to FIGS. 35-38.

A. Pre-tabulating Steiner-Tree Routes

FIGS. 20-34 illustrate one manner of pre-tabulating Steiner trees thatmodel possible net configurations with respect to the partitioning grid.The pre-tabulation of attributes of these trees are also describedbelow. As mentioned above, a router can use such pre-tabulated routesand/or attributes during the routing process. Other EDA applications canalso use these routes and/or attributes. For instance, as disclosed inUnited States patent application entitled “Recursive PartitioningPlacement Method and Apparatus”, filed on Dec. 6, 2000, and having theSer. No. 09/732,181, placers might use pre-tabulated wirelength,path-count values, and/or path-probability values to measure the cost ofa placement.

1. Calculating the Length of an Interconnect Line Connecting Two Nodesof a Tree.

FIGS. 20 and 21 illustrate how some embodiments calculate the length ofan interconnect line connecting two nodes of a tree. These embodimentsperform these operations by treating the two nodes as opposing cornersof a bounding box that has a long side (L) and a short side (S).

FIGS. 20 presents an example of a bounding-box 2005 for two nodes 2035and 2040. As shown in this figure, the line 2010 traverses the shortestdistance between nodes 2035 and 2040 for layouts that utilizehorizontal, vertical, and diagonal interconnect lines. This line ispartially diagonal. Specifically, in this example, one segment 2020 ofthis line is diagonal, while another segment 2015 is horizontal.

Equation (A) below provides the distance traversed by line 2010 (i.e.,the minimum distance between the nodes 2035 and 2040).Distance=[L−{S(cos A/sin A)}]+S/sin A  (A)In this equation, “L” is the box's long side, which in this example isthe box's width 2025 along the x-axis, while “S” is the box's shortside, which in this example is its height 2030 along the y-axis. Also,in this equation, “A” is the angle that the diagonal segment 2020 makeswith respect to the long side of the bounding box. In some embodiments,this angle A corresponds to the direction of some of the diagonalinterconnect lines in the layout. For instance, in some embodiments, theangle A equals 45° when the layout uses the octagonal wiring modelillustrated in FIG. 3.

Equations (B)-(D) below illustrate how Equation (A) is derived. Thelength of the line 2010 equals the sum of the lengths of its twosegments 2015 and 2020. Equation (B) provides the length of thehorizontal segment 2015, while Equation (C) provides the length of thediagonal segment 2020.Length of 2015=L−(Length of 2020)*(cos A)  (B)Length of 2020=S/sin A  (C)Equations (B) and (C) can be combined to obtain Equation (D) below,which when simplified provides Equation (A) above.Distance=Length of 2015+Length of 2020=L−S/sin A*(cos A)+S/sin A  (D)When the angle A equals 45°, Equation (A) simplifies to Equation (E)below.Distance=L+S*(sqrt(2)−1)  (E)

When the bounding box has no width or height, then the bounding box isjust a line, and the minimum distance between the opposing corners ofthis line is provided by the box's long (and only) side, which will be ahorizontal or vertical line. When the bounding box has equal sizedheight and width (i.e., when it is a square) and the angle A is 45°, aline that is completely diagonal specifies the shortest distance betweenthe box's two opposing corners.

FIG. 21 illustrates a process 2100 that identifies a bounding box fortwo nodes of a tree, and calculates the length of an interconnect lineconnecting the two nodes based on the bounding box's dimensions andEquation (A). This process initially (at 2105) determines whether thex-coordinate (X₁) of the first node is greater than the x-coordinate(X₂) of the second node. If so, the process defines (at 2110) thex-coordinate (X₁) of the first node as the maximum x-coordinate(X_(Max)), and the x-coordinate (X₂) of the second node as the minimumx-coordinate (X_(Min)). Otherwise, the process defines (at 2115) thex-coordinate (X₂) of the second node as the maximum x-coordinate(X_(Max)), and the x-coordinate (X₁) of the first node as the minimumx-coordinate (X_(Min)).

Next, the process determines (at 2120) whether the y-coordinate (Y₁) ofthe first node is greater than the y-coordinate (Y₂) of the second node.If so, the process defines (at 2125) the y-coordinate (Y₁) of the firstnode as the maximum y-coordinate (Y_(Max)), and the y-coordinate (Y₂) ofthe second node as the minimum y-coordinate (Y_(Min)). Otherwise, theprocess defines (at 2130) the y-coordinate (Y₂) of the second node asthe maximum y-coordinate (Y_(Max)), and the y-coordinate (Y₁) of thefirst node as the minimum y-coordinate (Y_(Min)).

The process then defines (at 2135) the four coordinates of the boundingbox as (X_(MIN), Y_(MIN)), (X_(MIN), Y_(MAX)), (X_(MAX), Y_(MIN)), and(X_(MAX), Y_(MAX)). Next, the process determines (at 2140) thebounding-box's width and height. The process determines (1) the width bytaking the difference between the box's maximum and minimumx-coordinates, and (2) the height by taking the difference between thebox's maximum and minimum y-coordinates. The process then determines (at2145) whether the computed width is greater than the computed height. Ifso, the process defines (2150) the width as the long side and the heightas the short side. Otherwise, the process defines (at 2155) the width asthe short side and the height as the long side.

After 2150 or 2155, the process then uses (at 2160) the above-describedEquation (A) to compute the length of the shortest interconnect linethat connects the two nodes. The process then ends.

2. Constructing Steiner Trees for All Possible Net Configurations andPre-tabulating Length and Wiring Path Information for each Tree.

FIG. 22 illustrates a process 2200 that (1) constructs one or moreoptimal Steiner trees for each possible net configuration with respectto a partitioning grid, (2) stores the length of each constructedSteiner tree in a storage structure, such as a look-up table (“LUT”),(3) computes and stores the probability of the trees using each wirepath in the grid, and (4) stores the identity of each tree by storingthe wire paths for each tree in the storage structure.

This process 2200 is performed before the router starts its operation,so that the router does not have to construct in real-time Steiner treesfor each net configuration. Instead, because of process 2200, the routerneeds only (1) to identify the configuration of each net with respect tothe partitioning grid, and (2) to retrieve stored attributes for theidentified configuration.

As shown in FIG. 22, process 2200 initially starts (at 2205) by defininga tree node for each sub-region (also called slot) defined by aparticular partitioning grid. FIG. 23 pictorially illustrates sixteentree nodes 2305 for sixteen slots created by a 4-by-4 partitioning grid.These nodes represent all the potential nodes of trees that model theinterconnect topologies of all the net configurations. In FIG. 23, theidentified nodes are positioned at the center of each slot. In otherembodiments, the nodes can uniformly be defined at other locations inthe slots (e.g., can be uniformly positioned at one of the corners ofthe slots).

Next, the process 2200 defines (at 2210) a set N of possible nodeconfigurations. When the partitioning grid defines Y (e.g., four, nine,sixteen, twenty, etc.) sub-regions, set N includes 2^(Y) nodeconfigurations. After defining the set N of possible nodeconfigurations, the process 2200 selects (at 2215) one of the possiblenode configurations N_(T) from this set.

The process then constructs (at 2220) one or more minimum spanning trees(“MST's”) for the node configuration selected at 2215, and computes eachconstructed tree's length (MST_Cost). As further described below, eachconstructed MST can have edges that are completely or partiallydiagonal. A node configuration that has less than two nodes does nothave a MST, and accordingly its MST_Cost is zero. In addition, FIG. 25Aillustrates a process 2500 that constructs one or more MST's andcomputes each MST's length for node configurations with two or morenodes. This process 2500 will be described further below.

After 2220, the process 2200 identifies (at 2225) potential Steinernodes, and then defines (at 2230) all possible sets of Steiner nodes.One manner of identifying potential Steiner nodes will be explainedbelow by reference to FIG. 24. Each set of Steiner nodes that is definedat 2230 includes one or more of the Steiner nodes identified at 2225.Also, each defined set of Steiner nodes has a maximum size that is twonodes less than the number of nodes in the selected node configuration.

For each set of Steiner nodes identified at 2230, the process then (at2240) (1) constructs one or more MST's of the nodes in the selected nodeconfiguration and the selected Steiner-node set, and (2) computes andstores each MST's length (MST_Cost). Each constructed MST can use edgesthat are completely or partially diagonal. As mentioned above, a nodeconfiguration that has less than two nodes does not have a MST, andaccordingly its MST_Cost is zero. In addition, FIG. 25A illustrates aprocess 2500 that constructs one or more MST's and computes each MST'slength for node configurations with two or more nodes. This process 2500will be described further below.

Next, the process 2200 selects (at 2240) the shortest set of the MST'sgenerated at 2220 or 2235 as the optimal Steiner trees for the currentnode configuration. In other embodiments, this process uses othercriteria to select its set of Steiner trees. At 2240, the process alsostores in a storage structure (such as a LUT) the length (MST_Cost) ofthe Steiner tree or trees identified at 2240.

After selecting one or more Steiner trees for the current nodeconfiguration at 2240, the process 2200 calls (at 2245) a process 2600to calculate the routing-path information and the path-usageprobabilities resulting from the selected Steiner trees. This processwill be described below by reference to FIG. 26.

The process 2200 next determines (at 2250) whether it has examined allthe node configurations in the set N defined at 2210. If not, theprocess returns to 2215 to select an unexamined node configuration fromthis set and then repeat operations 2220-45 for the newly selected nodeconfiguration. Otherwise, the process ends.

FIG. 24 illustrates a process 2400 for identifying potential Steinernodes. The process 2400 of FIG. 24 only needs to be performed for nodeconfigurations with three or more nodes, because each set of Steinernodes defined at 2220 has a maximum size that is two nodes less than thenumber of nodes in the selected node configuration (i.e., becauseSteiner-node sets are not defined at 2220 for node configurations withtwo or fewer nodes).

The process 2400 starts (at 2405) by initializing a set P of potentialSteiner nodes equal to all the nodes defined at 2205 that are not partof the node configuration selected at 2215. This process then selects(at 2410) one of the potential Steiner nodes. Next, the process 2400determines (at 2415) whether the node (Q) selected at 2410 is on ashortest path between any two nodes in the selected node configuration.To make this determination, the process determines whether any two nodes(B and C) exit in the node configuration such that the distance betweenthe two nodes (B and C) equals the sum of (1) the distance between thefirst node (B) and the selected node (Q), and (2) the distance betweenthe second node (C) and the selected node (Q). In some embodiments, theprocess uses the above-described process 2100 and Equation (A) tocalculate the distance between any pair of nodes.

If the process determines that the node Q selected at 2410 lies on ashortest path between any two nodes in the node configuration, theprocess keeps (at 2420) the selected node in the set P of potentialSteiner nodes, flags this node as a node that it has examined, andtransitions to 2430, which is described below. On the other hand, if theselected node (Q) is not on the shortest path between any two nodes inthe selected node configuration, the process removes (at 2425) theselected node from the set P of potential Steiner nodes, and transitionsto 2430.

At 2430, the process determines whether it has examined all the nodes inthe set of potential Steiner nodes. If not, the process returns to 2410to select another node in this set so that it can determine at 2415whether this node is on a shortest path between any two nodes in theselected node configuration. When the process determines (at 2430) thatit has examined all the nodes in the set of potential Steiner nodes, itends.

FIG. 25A illustrates a process 2500 that the process 2200 of FIG. 22uses at 2220 and 2235 to construct minimum spanning trees. A minimumspanning tree for a node configuration is a tree that has N−1 edges thatconnect (i.e., span) the N nodes of the configuration through theshortest route, which only branches (i.e., starts or ends) at the nodes.

In some embodiments of the invention, the edges of the MST's can behorizontal, vertical, or diagonal. The diagonal edges can be completelyor partially diagonal. Also, when the layouts use diagonal interconnectlines (e.g., ±45° interconnect lines), the diagonal edges of the MST'scan be in the same direction (e.g., can be in ±45° direction) as some ofthe diagonal interconnect lines in the layout. For instance, when thelayout uses an octagonal wiring model (i.e., uses horizontal, vertical,and 45° diagonal lines), some embodiments construct MST's that havehorizontal, vertical, and 45° diagonal edges.

By treating the two nodes of each edge of an MST as two opposing cornersof a bounding box, the length of each edge can be obtained by using theabove-described process 2100 and Equation (A).Distance=[L−{S(cos A/sin A)}]+S/sin A  (A)As described above, in this equation, “L” is the box's long side, “S” isthe box's short side, and “A” is the angle that the diagonal segment ofthe edge makes with respect to the long side of the bounding box.

The process 2500 starts whenever the process 2200 calls it (at 2220 or2235) (1) to construct one or more MST's for a set M of nodes, and (2)to calculate the length of each constructed MST. This process initially(at 2505) sets the MST length (MST_Cost) to zero. Next, the process (at2510) (1) selects a node from the received set M of nodes as the firstnode of the spanning tree, and (2) removes this node from this set M.

The process 2500 then calls (at 2515) a process 2550 illustrated in FIG.25B, in order to identify one or more linked set of nodes that representone or more complete MST's. The process 2550 is a recursive processthat, when called, receives (1) a set of nodes that represents anincomplete MST, and (2) a set of nodes M that are the nodes of the nodeconfiguration that have not yet been added to the received incompleteMST. When the process 2500 calls the process 2550, it supplies theprocess 2550 the first node selected at 2510, and the modified set ofremaining nodes M. In response, the recursive process 2550 returns oneor more linked set of nodes that represent one or more MST's, as furtherdescribed below. The process 2550 might return more than one copy of thesame linked node set. Accordingly, after the process 2500 receives oneor more linked node sets from process 2550, the process 2500 eliminates(at 2520) any duplicate copy of the same received linked node set, sothat there is only one copy of each received node set. After 2520, theprocess 2500 returns the constructed MST's and their lengths, and thenends.

As shown in FIG. 25B, the process 2550 defines (at 2525) a remainder setR of nodes equal to the set M of nodes that it received when it wascalled. At 2530, the process 2550 selects a node from the remaining nodeset R, and removes the selected node from the set of remaining nodes.The process then computes and stores (at 2535) the distance between thenode selected at 2530 and each current node of the received incompleteMST. The distance between the selected node and each node can betraversed by an edge that is completely or partially diagonal. Hence, insome embodiments, the process 2550 uses the above-described process 2100and Equation (A) to compute the minimum distance between the selectednode and each node.

Next, the process determines (at 2540) whether there is any noderemaining in set R. If so, the process returns to 2530 to select anothernode from this set, so that it can compute (at 2535) the distancebetween this node and the current nodes of the spanning tree. Otherwise,the process (at 2545) identifies the smallest distance recorded at 2535,and identifies the node pair or pairs (where, in each pair one node isfrom the received set M and one node is from the received MST) thatresulted in this distance.

The process 2550 then (at 2555) adds the identified smallest distance tothe MST length (MST_Cost). Next, the process determines (at 2560)whether it identified more than one pair of closest nodes. If not (i.e.,if the identified minimum distance is between only one node in set M andonly one node in the MST), the process (at 2565) (1) defines a tree nodecorresponding to the set-M node identified at 2545, (2) removes theidentified node from set M, and (3) links the defined tree node to theMST node identified at 2545. At 2565, the process 2550 also recursivelycalls itself and supplies the modified MST and the modified set M, whenset M is empty after the removal of the identified node. On the otherhand, when the modified set M is empty, the process 2550 transitionsfrom 2565 to 2575, where it returns one set of nodes that represents onecomplete MST that was completed by the linking at 2565. After 2575, theprocess 2550 terminates.

If the process 2550 determines (at 2560) that it identified (at 2545)more than one “closest” node pairs, it sequentially and recursivelytries to obtain a complete MST based on each identified closest nodepair. In other words, this process initially selects one of theidentified node pairs, and then (1) removes the selected pair's set-Mnode from set M, (2) links the removed node to the pair's MST node, and(3) recursively repeats for the modified MST and the modified set M.Once the process 2550 receives the results of this recursion (i.e., whenthis process receives the complete MST's for the selected node pair), itthen selects the next identified node pair, and performs the same threeoperations in order to obtain complete MST's based on this node pair.The process continues in this manner until it generates the MST's basedon each of the identified “closest” node pairs. After sequentiallyprocessing each identified node pair, the process returns (at 2575) theMST's, and then terminates.

FIG. 26 illustrates a process 2600 that calculates the routing-pathinformation and the path-usage probabilities resulting from the Steinertrees selected at 2250. This process 2600 starts each time process 2200calls it at 2245 and provides it with a set of Steiner trees.

The process 2600 starts by initializing (at 2605) a global countvariable that stores a count value for each path. For each receivedtree, the process initializes (at 2610) a bit string for storing thattree's routing path information. The process then selects (at 2615) areceived Steiner tree, and selects (at 2620) one of the edges in thetree (i.e., selects a pair of linked nodes in the tree, where thesenodes were linked at 2565 or 2570 of process 2550). Next, the processdetermines (at 2625) whether more than one set of paths exist to routethe selected tree edge (i.e., to connect the selected pair of nodes). Insome embodiments, the process retrieves the path values for the selectedtree edge from a storage structure (e.g., a LUT) that stores path-usagevalues for any combination of the tree slot nodes. In other words, thisstorage structure maps the endpoints of each possible tree edge withinthe grid to a set of path-usage values.

When the tree edge endpoints are not adjacent (i.e., when the pair ofnodes selected at 2620 are not adjacent), more than one optimal routemight exist between the endpoints (i.e., between the node pairs). Hence,the path-usage values in the LUT might specify values for multipleoptimal routes.

Two sets of node connections that could represent the three Steinertrees shown in FIGS. 6-8 are (1)node set formed by node 610-node615-Steiner node 620-node 625-node 630 for the Steiner tree 605 of FIG.6, and (2) the node set formed by node 625-node 610-node 615-node 635for the Steiner trees of FIG. 7 or 8.

In the first set of nodes representing the Steiner tree 605 of FIG. 6,only one route exists between any two connected pairs of nodes. Hence,for any pair from this set, the mapping LUT would return 42 values, withall the values equal to 0 except the value for the path between theselected node pair. This non-zero value would be 1 to indicate that onlyone route exists between the selected node pair.

On the other hand, for the second set of nodes representing eitherSteiner tree 705 or 805, two routes exist between nodes 615 and 630. TheSteiner tree 705 uses one of these routes, while the Steiner tree 805uses the other. For this node pair (i.e., for nodes 615 and 630) in thisnode set, the mapping LUT would return two 42-bit strings, one forSteiner tree 705 and one for Steiner tree 805. The bit string for tree805 has values for paths 1 and 28 set to 1 and the remaining values setto 0, while the bit string for tree 705 will have values for paths 5 and26 set to 1 and the remaining values set to 0.

If the process did not retrieve more than one bit string at 2625, ittransitions to 2635, which will be described below. Otherwise, when theprocess retrieves N bit strings (where N is an integer equal or greaterthan 2) for N routes for routing the selected tree edge (i.e., forconnecting the selected pair of nodes), the process makes N−1 duplicatecopies of the current bit string or strings of the current tree, andembeds the different routes among the copies of the tree.

In other words, the process makes (at 2630) N−1 duplicate copies of thebit string or strings of the current tree; a bit string for the currenttree was initialized at 2610, and the current tree will have multiplebit strings if its bit string was previously duplicated at 2630. From2630, the process transitions to 2635.

At 2635, the process modifies the bit string or strings for the currenttree with the bit string or strings (retrieved at 2625) for the selectedtree edge. Next, the process determines (at 2640) whether it hasexamined the last edge of the current tree (i.e., whether it hasexamined the last linked node pair in the current tree). If not, theprocess transitions back to 2620 to select the next tree edge (i.e., thenext linked node pair).

When the process determines (at 2640) that it has examined the last treeedge, it then determines (2645) whether it has examined the last treesupplied by the process 2200. If not, the process returns to 2615 toselect another tree and then determine the path-usage for this tree.Otherwise, the process transitions to 2650.

By the time the process 2600 reaches 2650, it has generated bit-stringrepresentation of one or more trees. Each tree's bit-stringrepresentation is a 42-bit string. As mentioned above, onenode-representation of a tree might result in multiple bit-stringrepresentations when the tree's node set has one or more pairs of linkednodes that are not adjacent and one or more sets of paths exist betweenthe non-adjacent linked pairs.

In addition, a node configuration selected at 2215 might result indifferent MST node representations (i.e., different node-representedMST's) that produce identical MST bit representations (i.e., produceidentical bit-represented MST's). Accordingly, at 2650, the processexamines all the bit-string-represented trees and eliminates anyduplicate copy of the same bit-string-represented tree.

When a node configuration selected at 2215 results in a large number ofbit-string-represented trees, the process 2600 can use a binary searchtree (“BST”) to quickly sort and search the trees and thereby quicklyidentify and eliminate duplicate copies of the same tree. One such BSTis described below by reference to FIGS. 32 and 33.

All the bit-represented trees that remain after 2650 are unique. Hence,after eliminating duplicate copies of the same trees, the process 2600stores (at 2655) all bit-string-represented trees that remain in astorage structure (such as a LUT). As described in the example below,each bit string specifies the route of a routing tree for the currentnode configuration. Specifically, as described in the example below,each stored bit string specifies the routing paths that a routing treefor the current node configuration traverses. At 2655, the processincrements each path value of the global count variable with eachbit-string-represented tree's corresponding path value, in order togenerate a total count value for each path. The process then recordsthis usage count for each path. Also, for each particular path, theprocess (at 2650) (1) divides the usage count by the number of the treesremaining after 2650 in order to obtain the usage probability value ofthe particular path, and then (2) stores this resulting probabilityvalue. The process then ends.

For the Steiner trees shown in FIGS. 6-8, the process 2600 wouldidentify three strings of 42-bits that specify the routing pathinformation for the three trees 605, 705, 805. These three bits stringsfor trees 605, 705, and 805 would respectively be:

000000000010000000000000000010000000110001;

000000000000000100000000010001000000100001;

000000000000010000000000010001000000000011.

(In this document, the least significant bit (“LSB”) of a bitstring isthe rightmost bit, and the most significant bit (“MSB”) of the bitstringis the leftmost bit.) FIGS. 27 and 28 respectively illustrate examplesof path-usage counts and path-usage probabilities for the Steiner trees605, 705, and 805 of FIGS. 6-8. In the discussion below, path-usageprobability values are referred to as “probabilistic Steiner treevalues.”

3. Retrieving Steiner Trees

When the Steiner-tree routes are pre-tabulated according to process2200, a router at run-time identifies one or more Steiner-treeattributes (e.g., routes) for a net in the following manner. The routerfirst identifies the net's configuration with respect to thepartitioning grid. It then uses the identified configuration to retrieveone or more attributes (e.g., routes) that are stored for the identifiedconfiguration in the storage structure.

In some embodiments, the storage structure is a look-up table (“LUT”) offloating point numbers. In some of these embodiments, the LUT is indexedby a configuration code. In other words, to retrieve a particularattribute for a particular net configuration, the configuration code forthe net configuration is identified, and this configuration code is usedto identify the entry in the LUT that stores the desired attribute.

Some embodiments use the octagonal wiring model illustrated in FIG. 3,and specify each net's routing path in terms of the 42 diagonal andManhattan routing paths illustrated in FIG. 12. In some of theseembodiments, the LUT stores 42-bits for each route, where each bitrepresents one of the 42 paths. Also, each net's configuration code is a16-bit number, where each bit represents a sub-region defined by the 4×4partitioning grid. Each configuration-code bit is set (e.g., equals 1)when the associated net has a pin in the sub-region represented by theconfiguration-code bit, and is not set (e.g., equals 0) when theassociated net does not have a pin in this sub-region. Also, in theseembodiments, there are 2¹⁶ configuration codes that represent the 2¹⁶possible net configurations.

For instance, the net configuration code is 000001000000001, when thenet has a pin in slots 0 and 9. For such a configuration, someembodiments pre-tabulate two trees, one that uses paths P17 and P24, andanother that uses paths P12 and P30. Each of these trees can bespecified by a string of 42 bits. The bit string for the first tree is,

000000000000000001000000100000000000000000,

while the bit string for the second tree is,

000000000001000000000000000001000000000000.

Some embodiments store these two bit strings in a LUT, and retrievethese two bit strings by using the 16-bit configuration code of the netconfiguration 0000001000000001.

4. Storing Steiner Trees in a Compressed Form

A variety of compression techniques can be employed to store and useSteiner-tree routes for sets of net configurations. One such techniqueis illustrated in FIG. 29. The process 2900 of this figure is similar tothe process 2200 described above, except that the process 2900 has twoadditional operations 2905 and 2910, and has slightly differentoperations 2215 and 2250. Operations 2205, 2210, and 2220-2245 ofprocess 2900 are identical to similarly numbered operations 2205, 2210,and 2220-2245 of process 2200. Accordingly, these operations 2205, 2210,and 2220-2245 will not be further described below, in order not toobscure the description of the invention with unnecessary detail.

The process 2900 performs the additional operations 2905 and 2910 toreduce the amount of information that is pre-tabulated. The firstoperation 2905 reduces the number of potential net configurations forwhich the process 2900 pre-tabulates routes, while the second operation2910 ensures that the process 2900 stores each Steiner-tree route onlyonce.

Both of these operations are further described below. One of ordinaryskill, however, will realize that some embodiments do not use both theseoperations. For instance, some embodiments might only perform 2910 toensure that each Steiner-tree route is only stored once.

a. Symmetrical Net Configurations

The operation 2905 groups the potential net configuration identified at2210 into sets of symmetrical net configurations. From 2215-2250, theprocess 2900 then generates and stores one set of Steiner trees for onedesignated net configuration of each group of symmetricalconfigurations. This flow is directed by 2215 and 2250. At 2215, theprocess 2900 selects a designated node configuration that it has notpreviously examined. At 2250, the process determines whether it hasexamined the designated node configuration for each group of symmetricnode configurations. At run-time, the designated configuration of eachgroup directly uses the pre-tabulated routes for its group, while thenon-designated configurations of each group generate their routes fromthe pre-tabulated routes for their group.

FIGS. 30 and 31 illustrate one technique for performing this grouping.This technique is performed for FIG. 5's 4×4 partitioning grid. In thisgrid, each net configuration is symmetrical with respect to seven othernet configurations. These seven symmetrical configurations can beidentified by (1) rotating the net configuration by 90°, (2) rotating itby 180°, (3) rotating it by 270°, (4) flipping the net configurationabout the x-axis, (5) rotating the net configuration by 90° and flippingthe result about the x-axis, (6) rotating it by 180° and flipping theresult about the x-axis, (7) rotating it by 270° and flipping the resultabout the x-axis.

In the embodiments described below, the rotation and flip operations aredefined with respect to a Cartesian coordinate system that has (1) anx-axis parallel to the width of the 4×4 partitioning grid (i.e., widthof the layout), (2) a y-axis parallel to the height of the grid, and (3)an origin at the intersection of grid's slots 5, 6, 9, and 10, which areillustrated in FIG. 5. Specifically, the rotation is defined in terms ofa clockwise rotation about the origin. The flipping of a configurationinvolves changing the sign of the y-coordinate of each configurationslot. Table 1 below illustrates an example of eight net configurationsthat are related based on the above-described symmetrical relationship.

TABLE 1 Configuration Slots With Pins Description of Symmetry0000000100000001 0, 9 Original configuration 0000101000000000 10, 12Rotate by 90° 1000000000100000  6, 15 Rotate by 180° 0000000000101000 3,5 Rotate by 270° 0000001000001000  5, 12 Flip about x-axis1000000100000000 0, 6 Rotate by 90° and flip about x-axis0001000000100000  3, 10 Rotate by 180° and flip about x-axis0000000001000001  9, 15 Rotate by 270° and flip about x-axis

FIG. 31 illustrates a process 3100 for grouping net configurationsaccording to the symmetries described above. FIG. 30 illustrates fourdata fields that the process 3100 stores for each configuration. Thefirst field 3000 stores the configuration's 16-bit pin distribution(i.e., its net/node configuration). The second field 3005 specifieswhether the process 3100 has already grouped the configuration withother configurations.

The third field 3010 is a reference (e.g., a pointer) to a treelist3020, which includes one or more references to one or more Steiner-treeroutes 3025 for the configuration's group. Each configuration in a grouprefers to the same treelist 3020. For instance, FIG. 30 illustratesthree grouped configurations 3030, 3035, and 3040 that refer to the sametreelist. The fourth field 3015 stores the symmetrical-relationidentifier. This identifier specifies how to obtain trees for the netconfiguration from the trees stored for the group. In other words, eachconfiguration's identifier specifies how to transform one or more treesthat are pre-tabulated for the configuration's group into one or moretrees for the configuration.

The process 2900 performs process 3100 at 2905 after the process 2900defines (at 2210) all sets of potential node configurations. As shown inFIG. 31, the process 3100 initially selects (at 3105) one of the nodeconfigurations that was defined at 2210. It then marks (at 3110) thisconfiguration as grouped in its configurations field 3005.

Next, the process records (at 3115) “NONE” in this configuration'srelation-identifier field 3015. This marking indicates that thepre-tabulated trees specified for this configuration (i.e., the treesthat will be referred to by this configuration's treelist 3020) do notneed to be transformed in any manner for the selected nodeconfiguration. In each group of configurations, the configuration thathas “NONE” recorded in its relation-identifier field is the designatedconfiguration for the group (i.e., it is the configuration that candirectly use the Steiner trees that are generated for the group).

At 3120, the process then creates a treelist 3020 for thisconfiguration's group, and links this configuration's reference field3010 to this treelist. To this treelist, the process 2900 will add (at2910) references that refer to the trees for this configuration's group.

The process 3100 then selects (at 3125) one of the seven symmetricalrelationships described above. It next uses (at 3130) the selectedsymmetrical relationship to identify one of the seven configurationsthat are symmetrically related to the configuration selected at 3105.Some embodiments have seven LUT's, one for each symmetrical-transformrelationship. Each LUT provides a one-to-one mapping that specifies asymmetrical node for each potential node of a designated nodeconfiguration. For instance, Table 2 below identifies the correspondingnodes for the symmetrical configuration that can be obtained by rotatingthe designated node configuration by 90°.

TABLE 2 Node of Designated Corresponding Node of the 90°- ConfigurationRotated Symmetrical Configuration Slot 0  Slot 12 Slot 1 Slot 8 Slot 2Slot 4 Slot 3 Slot 0 Slot 4  Slot 13 Slot 5 Slot 9 Slot 6 Slot 5 Slot 7Slot 1 Slot 8  Slot 14 Slot 9  Slot 10  Slot 10 Slot 6  Slot 11 Slot 2 Slot 12  Slot 15  Slot 13  Slot 11  Slot 14 Slot 7  Slot 15 Slot 3

At 3135, the process then marks the configuration identified at 3130 asgrouped in the configuration's field 3005. It next records (at 3140) theidentity of the relationship selected at 3125 (e.g., rotated by 90°) inthe configuration's relationship-identifier field 3015. This operationcan be used at run-time to transform one or more trees that arepre-tabulated for the configuration's group into one or more trees forthe configuration identified at 3130.

The process then links (at 3145) the reference field 3010 of theidentified configuration to the treelist 3020 for this configuration'sgroup. At 3150, the process then determines whether it has generated allseven configurations that are symmetrically related to the one selectedat 3105. If not, the process selects (at 3125) another symmetricalrelationship, and then performs 3130-3145 to identify the relatedconfiguration and populate its group fields.

When the process determines (at 3150) that it has generated all sevenconfigurations related to the configuration selected at 3105, itdetermines (at 3155) whether it has examined all node configurationsthat the process 2900 generated at 2210 (i.e., whether it has marked allgenerated node configurations as “grouped”). If not, the processtransitions to 3105 to select a node configuration that has not yet beenmarked as “grouped,” and repeats the above-described operations for thenewly selected configuration and its symmetrically-relatedconfigurations. When the process determines (at 3155) that it hasexamined all node configurations, it ends.

b. Storing Each Tree Only Once

At 2910, the process ensures that the process 2900 stores eachSteiner-tree route only once for any node configuration that might usesuch a route. Like process 2200 of FIG. 22, the process 2900 calls (at2245) the process 2600 to calculate the routing-path information for theSteiner tree or trees that the process 2900 identified for a nodeconfiguration. The process 2600 identifies one or more bit strings torepresent each Steiner tree identified by process 2900. The process 2600also (1) eliminates (at 2650) any duplicate copies of eachbit-represented tree that it generates for the same node configuration,and then (2) stores (at 26555) each remaining bit-represented tree.

However, when the process 2600 works in conjunction with process 2900,it does not permanently store (at 2655) each generated bit string.Instead, it returns the generated bit strings to process 2900. Theprocess 2900 then checks (at 2910) whether it previously stored eachreturned bit string (i.e., each returned Steiner tree) in the storagestructure for previous node configuration (i.e., for a nodeconfiguration that was previously selected at 2215). If so, the processdoes not re-store this bit string, but rather links one of thereferences in the node configuration's treelist 3020 to thepreviously-stored bit string. If not, the process stores this bit stringin the storage structure 3050 of FIG. 30 and links one of the referencesin the node configuration's treelist 3020 to the newly-stored bitstring.

A variety of different techniques can be used to check (at 2910) whetherthe process 2900 previously stored a bit string in the storage structure3050. The embodiments described below use a binary-search tree toperform this checking operation.

FIG. 32 illustrates one such binary-search tree (“BST”). This tree 3200has numerous nodes 3220, with each node having zero or two child nodes.Each node in the tree includes two references 3205 and 3210 forreferring to the node's left and right child nodes. Each node also has areference 3215 for referring to a 42-bit Steiner tree that correspondsto the node.

The BST has forty-two levels, where each level corresponds to one of thebits in the 42-bit string for representing Steiner trees. The BST levelsare in the same order as the bits in the bit string. Accordingly, theBST's 0^(th) level corresponds to the string's 0^(th) bit (i.e., the bitcorresponding to path 0), the BST's 1^(st) level corresponds to thestring's 1^(st) bit (i.e., the bit corresponding to path 1), the BST's2^(nd) level corresponds to the string's 2^(nd) bit (i.e., the bitcorresponding to path 2), etc. At each level, the value of the stringbit corresponding to that level determines the branching.

FIG. 33 illustrates a process 3300 that the process 2900 uses (at 2910)to traverse the BST 3200 to determine whether a Steiner tree waspreviously stored in the storage structure. As shown in FIG. 33, theprocess 3300 initially sets (at 3305) a variable L to 0. This variablespecifies the BST's level that the process 3300 is currently examining.At 3310, the process determines whether the L^(th) bit in the bit stringis a 0. If not, the process (at 3315) increments the variable L by one,and defines the current node's left child node as the current node. Ifso, the process increments (at 3320) the variable L by one, and definesthe current node's right child node as the current node.

From 3315 or 3320, the process transitions to 3325. Here, the processdetermines whether it has examined all the bits in the bit string, andif not, whether all the remaining unexamined bits (i.e., the L^(th) bitto the 41^(st) bit of the bitstring) are 0. If all the bits have notbeen examined and one or more of the unexamined bits have a value of 1,the process returns to 3310 to examine the current node.

On the other hand, if all the bits have been examined or all of theunexamined bits are 0, the process has found the node that should storethe bit string. Accordingly, the process determines (at 3330) whetherthe current node's tree reference 3215 refers to a stored tree (i.e., astored bit string). If not, the process stores (at 3335) the bit stringin the storage structure 3050 and links the current node's treereference 3215 to this structure. The process also links (at 3335) oneof the references in the node configuration's treelist 3020 to thenewly-stored bit string. If the process determines (at 3330) that thecurrent node's tree reference 3215 refers to a previously-stored bitstring, the process just links (at 3340) one of the references in thenode configuration's treelist 3020 to the previously-stored bit string.After 3335 or 3340, the process ends.

c. Identifying Routes From the Compressed Pre-Tabulated Table

When the Steiner-tree routes are pre-tabulated according to process2900, a router at run-time identifies one or more Steiner-tree routesfor a net in the following manner. The router first identifies the net'sconfiguration with respect to the partitioning grid. From the storagestructure 3050, it then retrieves one or more routes 3025 specified bythe treelist 3020 of the identified configuration.

The process then identifies the symmetrical relationship between theidentified net configuration and the designated configuration for itsgroup. It next uses this relationship to identify one or more routes forthe identified net configuration from the retrieved routes. To do this,some embodiments use seven LUT's, one for each symmetrical-transformrelationship. Each LUT provides a one-to-one mapping that specifies apath that is symmetrical to each potential path that a route of thedesignated node fi configuration can use.

For instance, the net configuration might be 0001010000000000, whichindicates the net having a pin in slot 10 and 12. This configuration issymmetrically related to the net configuration 0000001000000001, whichindicates the net having a pin in slot 0 and 9. Specifically, theconfiguration 0001010000000000 is obtained when the configuration0000001000000001 is rotated by 90°.

When the net configuration 0000001000000001 is the designatedconfiguration, some embodiments pre-tabulate two trees, one that usespaths P17 and P24 and another that uses paths P12 and P30. By rotatingthese tees by 90°, the router can identify two routes for theconfiguration 0001010000000000. To rotate each tree by 90°, the router(1) identifies each path used by the tree (i.e., identifies each set bitin the 42-bit string specifying the tree), and (2) from the 90°-rotationLUT, identifies the paths that are symmetrically related to theidentified paths for a 90° rotation of the partitioning grid.

Accordingly, from the 90°-rotation LUT, the router identifies path 37 asthe path related to path 24 through a 90° rotation, and identifies path7 as the path related to path 17 through a 90° rotation. From the90°-rotation LUT, the router identifies path 9 as the path related topath 12 through a 90° rotation, and identifies path 39 as the pathrelated to path 30 through a 90° rotation. In this manner, the routeridentifies two trees for the configuration 0001010000000000. One treeuses paths 7 and 37, and the other uses paths 9 and 39.

One of ordinary skill in the art will realize that other embodiments donot identify trees for symmetrical-node configurations by using LUT's.For instance, some embodiments might mathematically identify trees forsymmetrical-node configurations. For each symmetrical relationship,these embodiments might use a different mathematical equation to map thepaths of the pre-tabulated tree to the paths of thesymmetrically-related tree.

5. Pre-Tabulating Steiner Trees for Different Wiring Models.

Some embodiments of the invention pre-tabulate several sets of Steinertrees for several different wiring models. For instance, FIG. 34illustrates a process 3400 that performs the process 2200 or process2900 (1) once (at 3405) for a wiring model that has horizontal,vertical, and ±45° lines, (2) once (at 3410) for a wiring model that hashorizontal, vertical, and ±120° lines, and (3) once (at 3415) for awiring model that has horizontal and vertical lines.

To model all possible net configurations for a wiring model that useshorizontal, vertical, and ±45° lines, this process calculates (at 3405)the length, routing path, and path-usage values of Steiner trees withpotential 45° diagonal edges. In other words, at 3405, the process 3400uses 45° as the angle A in Equation (A) that is used by processes 2400and 2500 of process 2200 or 2900.

To model all possible net configurations for a wiring model that useshorizontal, vertical, and ±120° lines, this process calculates (at 3410)the length, routing path, and path-usage values of Steiner trees withpotential 120° diagonal edges. In other words, at 3410, the process 3400uses 120° as the angle A in Equation (A) that is used by processes 2400and 2500 of process 2200 or 2900.

To model all possible net configurations for a wiring model that useshorizontal and vertical lines, these embodiments calculate (at 3415) thelength, routing path, and path-usage values of Manhattan Steiner trees.In other words, at 3415, the process 3400 uses 90° as the angle A inEquation (A) that is used by processes 2400 and 2500 of process 2200 or2900.

B. Pre-Tabulating and Generating Trees

Some embodiments use net configurations to retrieve and generate routes.For instance, some embodiments use net configurations to retrievepre-tabulated routes for certain nets while generating routes for othernets. Several such embodiments will now be described by reference toFIGS. 35-38.

These embodiments pre-tabulate routes, referred to below as “minimumclosed trees” or MCT's, for closed node configurations. An MCT is a MSTfor a close node configuration. In other words, an MCT is a minimal treethat has N−1 edges that span the N nodes of the configuration throughthe shortest route, which only branches (i.e., starts or ends) at thenodes. For open node configurations, these embodiments pre-tabulatecertain related closed node configurations. The terms closed nodeconfigurations and open node configurations will be described below byreference to FIGS. 35A and 35B.

FIG. 35A illustrates an example of a closed node configuration 3505(including nodes 3515, 3520, 3530, 3535, and 3540), while FIG. 35Billustrates an example of an open node configuration 3510 (includingnodes 3515, 3530, 3535, and 3540). The node configuration 3505 is aclosed one since all the nodes in this configuration are adjacent to atleast one other node in the configuration. The node configuration 3510is an open one since node 3515 is not adjacent to another node in theconfiguration; in this configuration, node 3515 has node 3545 between itand the next closest node 3530.

Node configuration 3510 has several related closed node configurations.Two such configurations that do not result in MCT's with an “antenna”node are (1) a first configuration that includes 3515, 3545, 3530, 3535,and 3540, and (2) a second configuration that includes 3515, 3550, 3530,3535, and 3540. The first configuration is obtained by adding node 3545to configuration 3510, while the second configuration is obtained byadding node 3550 to configuration 3510.

A configuration that is obtained by adding node 3555 and either node3545 or 3550 to the configuration 3510 is a related closed configurationthat will always result in MCT's that have node 3555 as an antenna node.An antenna node in an MCT of a closed node configuration that isobtained by adding one set of nodes to an open node configuration, is anode that is part of the added set and that has only one of the MCT'sedges incident upon it. As further described below, the first two nodeconfigurations (configuration 3515, 3545, 3530, 3535, and 3540, andconfiguration 3515, 3550, 3530, 3535, and 3540) are related closed nodeconfigurations that can be pre-tabulated for the open node configuration3515, 3530, 3535, and 3540. The third configuration (3515, 3530, 3535,3540, and 3555), on the other hand, should not be pre-tabulated for thisopen configuration since it leads to an antenna node.

1. Pre-Tabulating MCT's

FIG. 36 illustrates a process 3600 that pre-tabulates MCT's for all nodeconfigurations within a particular partitioning grid, such as the 4-by-4grid of FIG. 5. As shown in FIG. 36, the process 3600 initiallyidentifies (3605) all potential node configurations.

It then selects (at 3610) a configuration. If the selected configurationis a closed one, the process next identifies (at 3615) all MCT's for theselected configuration. As mentioned above, a node configuration is aclosed one if each node in the configuration is adjacent to at least oneother node in the configuration. One of ordinary skill will appreciatethat the process 3600 can identify each MCT for the selectedconfiguration directly based on the sets of paths (e.g., the 42 pathsillustrated in FIG. 12) that exist between the nodes of the selectedclosed node configuration. Each MCT is a unique combination of N−1 ofsuch paths that connect all N nodes of the closed node configurationthrough the shortest route. Such MCT's can be identified through arecursive operation that explores all shortest paths between nodes ofthe closed configuration; in some embodiments, such a recursiveoperation would be similar to the one explained above by reference toFIGS. 25A and 25B, except that it specifies each MCT directly based onthe interconnecting paths.

At 3615, the process also computes the cost of each MCT identified at3615. In some embodiments, the process computes each MCT's cost by (1)assigning costs to the Manhattan and diagonal paths that connect theadjacent slots of the partitioning grid, (2) identifying the paths usedby the MCT, and (3) summing up the path costs. A node configuration thathas less than two nodes does not have a MCT, and accordingly its MCTcost is zero.

After 3615, the process determines (at 3620) whether it has examined allthe configurations. If not, the process returns to 3610 to selectanother one. Otherwise, the process ends.

2. Pre-Tabulating Related Closed Node Configurations

FIG. 37 illustrates a process 3700 that, for an open node configuration,pre-tabulates certain related closed node configurations. This processinitially identifies (at 3705) candidate sets of connection nodes. Eachcandidate set does not include any of the nodes of the open nodeconfiguration. Also, the candidate sets include all possible nodeconfigurations that can be obtained without the nodes of the open nodeconfiguration.

Next, the process selects (at 3710) a candidate set of connection nodes.The process then determines (at 3715) whether the combinedconfiguration, resulting from the addition of the selected candidate setand the open node configuration, has one or more pre-tabulated MCT's. Ifnot, the process transitions to 3745, which is described below.

If the combined configuration has one or more pre-tabulated MCT's, theprocess then performs 3720-3740 to determine whether the combined nodeconfiguration results in at least one MCT without antenna nodes. If allthe MCT's have an antenna nodes, then the combined configurationobtained for the candidate connection node selected at 3710 is notstored as a related closed configuration for the open nodeconfiguration.

Specifically, at 3720, the process selects one of the MCT's of thecombined configuration. It then identifies (at 3725) all nodes of thisMCT that have a degree 1 (i.e., all nodes that have only one of theMCT's path incident upon them). Next, the process determines (at 3730)whether all the identified nodes are part of the open nodeconfiguration. If so, the process accepts the combined configurationobtained with the candidate set selected at 3710, and stores (at 3740)the combined configuration (obtained by combining the candidate setselected at 3710 with the open node configuration) as a related closednode configuration for the open node configuration. From 3740, theprocess transitions to 3745, which will be described below.

On the other hand, if the process determines (at 3730) that at least oneof the nodes identified at 3725 is not part of the open nodeconfiguration, the process determines whether it has examined all of theMCT's for the combined node configuration. If not, the process returnsto 3720 to select another MCT. Otherwise, the process transitions to3745. At 3745, the process determines whether it has examined all of thecandidate sets of connection nodes. If not, the process transitions backto 3710 to select and examine another candidate set. Otherwise, theprocess ends.

3. Generating MCT's During Run-Time

When the routes and closed node configurations are pre-tabulatedaccording to processes 3600 and 3700, a router at run-time identifiesone or more routes for a net according to the process 3800 of FIG. 38.As shown in this figure, the process first identifies (at 3805) thenet's configuration with respect to the partitioning grid.

The router then determines (at 3810) whether the storage structurestores one or more MCT's for the identified configuration. If so, theprocess retrieves (at 3815) the stored MCT's for the configuration andstores them in the list of routes for the net. After 3815, the processthen ends.

On the other hand, if the process determines (at 3810) that the storagestructure does not store any MCT's for the identified configuration, theprocess retrieves (at 3820) the related closed node configurations forthe identified configuration. It then selects (at 3825) one of theretrieved closed configurations.

Next, the process retrieves (at 3830) the MCT's for the selected closedconfiguration. It then determines (at 3835) whether to store theretrieved MCT's for the identified node configuration. In someembodiments, the process makes this determination based purely on thewirelength cost of the MCT's. In other words, in these embodiments, theprocess stores the MCT's only if they are the shortest MCT's that theprocess has examined thus far for the identified node configuration. Inother embodiments, however, the process decides whether to store theMCT's based on other factors such as the estimated congestion of therouting paths, the estimated number of vias, the number of MCT'sselected thus far, etc. Also, in some embodiments, the process 3700sorts an open node configuration's closed node configurations in aparticular order. For instance, the process 3700 might sort the closedconfigurations that produce the shorter MCT's first. In theseembodiments, the process 3800 examines the closed node configurationsaccording to the stored order, and once it identifies the R number ofroutes, the process 3800 terminates.

If the process decides not to store the retrieved MCT's, the processtransitions to 3845, which is described below. However, if the processdecides (at 3830) to store the retrieved MCT's, its stores these MCT'sin a list of routes for the net configuration. The process thendetermines (at 3840) whether it has examined all the related closed nodeconfigurations for the identified net configuration. If not, the processreturns to 3820 to select another closed configuration; in someembodiments, the process might not return to 3820 to select anotherclosed configuration if it has already identifies a certain number ofMCT's. When the process determines that it has examined all the relatedclosed node configurations, the process ends.

VI. Recursive 4-By-4 Partitioning Router

A. Software Architecture.

FIG. 39 illustrates the software architecture of a router 3900 of someembodiments of the invention. This router can operate with a variety ofdifferent wiring architectures. It can also operate with differentpartitioning, congestion, and path-defining grids. However, in theembodiments described below, the router is primarily described to workin conjunction with (1) the octagonal wiring model that is illustratedin FIG. 3, (2) the partitioning grid that is illustrated in FIG. 5, and(3) the congestion grids and their associated 42 paths that areillustrated in FIGS. 9-12.

The software architecture of FIG. 39 includes several software modules3905 and several data constructs 3910. The software modules include aninitializer 3915, a slot manager 3925, a solver 3930, a propagator 3935,a saver 3940, a linear-programming (“LP”) solver 3945, aninteger-linear-programming (“ILP”) converter 3950, while the dataconstructs 3910 include LUT's 3965, circuit modules 3970, net list 3972,nets 3974, slots 3976, slot-nets 3978, paths 3980, and pins 3982.

The router 3900 defines partitioning grids that recursively divide adesign region (i.e., the IC layout or a region of the IC layout) intosmaller and smaller sub-regions. In the embodiments described below, therouter uses 3 evenly-spaced horizontal lines and 3 evenly-spacedvertical lines to recursively divide the design regions into 16identically-sized sub-regions (i.e., 16 identically-sized slots). FIG.40 illustrates a design region 4005 that is recursively divided intosets of 16 sub-regions. Specifically, the design region is dividedinitially into 16 sub-regions, each of these sub-regions is furtherdivided into 16 smaller sub-regions, and one of the smaller sub-regions4010 is further sub-divided into 16 sub-regions. At each recursionlevel, the router simply adjusts the coordinates of the partitioninggrid to match the coordinates of the IC region at that recursion level.In other embodiments, the router can use different shaped partitioninggrids for all or some recursion levels.

The router 3900 defines in a hierarchical, top-down manner the wiringpath values for each net in the design region. The router's initializer3915 initially determines the number of recursion levels, and the numberof slots resulting from this number of recursion levels. The initializeralso creates data structures for these slots. In addition, for eachslot, the initializer creates a slot-net data structure for each net inthe slot, and this slot-net data structure stores the net'sconfiguration within that slot. For each slot, the initializer alsoidentifies all the circuit modules that intersect this slot.

In some embodiments, the initializer also defines the capacities ofrouting paths within each slot and stores these capacities in the slot'sdata structure. In the embodiments described below, however, the slotmanager defines these capacities as it directs the routing of each slot.

For each slot that is partitioned into smaller child slots, the slotmanager directs the solver 3930 to select a route for each net that hasactual or virtual pins in the slot. The solver uses each net'sconfiguration (1) to identify one or more optimal routes for each net,and at times (2) to generate fake configuration to identify one or moresub-optimal routes for each net. The solver identifies one or moreroutes for a particular configuration based on any one of the approachesdescribed above in Section V.

The solver then formulates an LP problem and feeds these solutions tothe LP solver 3945, which, in turn, returns a number of real-numbersolutions. These real-number solutions are then converted into integersolutions by the ILP solver 3950. These integer solutions specify aparticular route for each net, and the solver stores each net's routeinformation in the net's slot-net data structure for the current slot.

After the solver specifies the route for each net that has an actual orvirtual pin in the current slot, the slot manager 3925 calls thepropagator 3935 if the current slot is not a leaf slot. A leaf slot is aslot that has child slots, but its child slots do not have any childslots (i.e., its child slots are not partitioned). The child slots of aleaf-level slot are called Gcells.

When called by the slot manager, the propagator determines how therouting paths specified by the solver for the current routing levelpropagate down into the child slots of the current slot. For slots thatare after the top-level slot and before the leaf-level slot, thepropagator also performs a follow-up propagation operation thatpropagates the routing paths specified by the propagator at the previousrouting level one level further down.

For each net in the current slot, the propagator has to determine thenet's pin distribution within all child slots affected by the net'srouting paths. The propagation process often entails adding virtual pinsin the current slot's grandchild slots (i.e., the child slots of thecurrent slot's child slots). In other words, the propagator might modifythe net's configuration within the child slots of the current slot.

Different embodiments of the invention use different propagators. Twodifferent propagators are described below. The first propagatorenumerates several propagation solutions for each net's route and thenuses the LP solver 3945 and ILP converter 3950 to select a propagationsolution for each net. The second propagator, on the other hand, is asequential propagator that uses a greedy approach to select and embed apropagation for the route of each net in the current slot. In theembodiments described below, both these propagators use a sequentialpropagator to perform the follow-up propagation, when applicable.

The identified propagations for each net's route specify a particularconfiguration for the net within each affected child slot, and thepropagator stores the net's configuration in the net's slot-net datastructure for the affected child slots. The embodiments described belowspecify each net's configuration by a string of 16 bits, where each bitcorresponds to a child slot of a slot.

After the solver has specified the route for each net in a leaf slot,the slot manager calls the saver 3940 to link the path structures ofeach net's route to their respective net's main data structures. Thesaver also links to the main net data structures the path datastructures of the propagation paths that the propagator specifies for aparent slot of a leaf-level slot (i.e., for a grandparent slot of aGcell). These propagation paths include paths that the propagatoridentified (1) for the routing paths specified by the solver and (2) forthe routing paths specified by the propagator at the previous routinglevel.

In this manner, the path data structures linked to a net's main datastructure collectively represent the final route for the net that therouter specifies. In some embodiments, such a route is a global routefor a net. FIGS. 49-83 further describe the software modules 3905.However, before describing these software modules, the data constructs3910 will be described below by reference to FIGS. 41-48.

B. Data Constructs.

1. LUT's.

The LUT's 3965 store information (such as routing paths, lengths,path-usage, etc.) about the routes that connect the sub-regionscontaining the circuit modules of the nets. Some of these routes haveedges that are completely or partially diagonal. In the embodimentsdescribed below, the LUT's store the length, routing paths, andpath-usage probability values of the routes for all possible netconfigurations. Several processes for selecting routes andpre-tabulating their length, routing paths, and path-usage probabilitieswere discussed above in Section V. One of ordinary skill will understandthat other embodiments also store other attributes of trees. In theembodiments that utilize the route-generating process 3800 of FIG. 38,the LUT's store for each open node configuration one or more relatedclosed node configurations.

In some embodiments, the router 3900 can operate with different wiringarchitectures. In these embodiments, different LUT's can be used tostore route attributes for the different wiring models. For instance,the LUT's can store routing information for (1) a first wiring modelthat uses Manhattan and ±45° diagonal lines, (2) a second wiring modelthat uses Manhattan and ±120° diagonal lines, (3) a third wiring modelthat only uses Manhattan lines, etc. Once the wiring model is selected,the routing information for each net configuration can be retrieved fromthe LUT that is appropriate for the selected wiring model.

In the embodiments where the router can operate with different wiringmodels, the router typically selects the wiring model at the beginningof the design process. For instances, in some embodiments, the process400 selects the wiring model at 405 before it selects the partitioninggrid. Also, some embodiments might switch from one wiring model toanother for different portions of the design process or at lower levelsof the design hierarchy.

In the embodiments described below, the router uses the octagonal wiringmodel that is illustrated in FIG. 3 throughout the routing process. Therouter uses a LUT that stores routing information (e.g., routes,lengths, path-usage values, trees for closed-sets of slots, sets ofnodes, etc.) for the congestion grids and their associated 42 paths thatare illustrated in FIGS. 9-12.

2. Net List, dbNet, Slot-Net, Pin, and Path Structures.

FIG. 41 illustrates the data structure for a net list 4100. This listincludes one or more fields 4105, each of which refers (e.g., points) toa dbNet data structure 4110. Each net has a dbNet data structure, whichserves as the main data structure for the net. FIG. 42 illustrates thedbNet data structure. This data structure includes an index field 4205that contains a value that some of the software modules (e.g., thepropagator) use to identify the net. This data structure also includes anumber of fields 4210 that refer (e.g., point) to pin data structures.

FIG. 43 illustrates a simple pin data structure 4300 that includes alocation field that specifies the pins location. In some embodiments,the pin's location is provided as a three-dimensional location that notonly specifies its x and y location, but also specifies its layer. Otherembodiments, however, store the pin's layer as part of a pin macro. Thispin macro can be stored as part of the circuit macro which is referencedby the slot-data structure as described below.

The dbNet data structure also includes one or more fields 4220, each ofwhich refers (e.g., points) to a path data structure 4400 such as theone illustrated in FIG. 44. In some embodiments, the saver links thepath data structures that specify the final lowest-level route paths foreach net to the dbNet of their respective nets through reference field4220.

The path data structure includes a field 4405 that specifies the pathtype as horizontal (H), vertical (V), a first diagonal direction (E), ora second diagonal direction (W). This structure also includes a field4410 to store the path id, which is a number from 0 to 41 thatidentifies the data structure's path as one of the 42 paths defined inthe two-grids. In addition, this data structure includes a field 4415that refers (e.g., points) to the dbNet associated with the path.Finally, this data structure has two fields 4420 that refer to the datastructures of the two slots that the path is incident upon. These twofields can be used during a verification process to ensure thecontinuity of the routes specified by the router 3900.

For each slot, the router 3900 defines a slot-net data structure foreach net that has an actual or virtual pin in the slot, and thisslot-net data structure stores the net's configuration within that slot.FIG. 45 illustrates this slot-net data structure. This structureincludes a field 4505 that refers (e.g., points) to the dbNet of itsnet. It also includes a field 4510 that stores a bit string thatspecifies its net's pin distribution in the slot. As discussed furtherbelow, the initializer initially sets this field based on all the actualpins of the net within the slot. During the recursion process, thepropagator might modify the bit string in this field 4510 to account forvirtual pins. The slot-net data structure also includes a field 4515that stores the 42-bit selected-route string. The solver sets this bitstring after it selects a route for net in the slot.

3. Slot.

The router 3900 recursively divides the design region into sets of 16sub-regions or slots. FIG. 46 presents a graph that conceptuallyillustrates the hierarchy of slots (i.e., sub-regions) defined by therouter. This graph 4600 illustrates two levels 4610 and 4615 of therecursion process. In this graph, each node represents an IC region at aparticular stage within the recursion process. Also, in this graph, theroot node represents the entire design region, while each non-root noderepresents a portion of the design region.

In a slot-hierarchy, each node has either 0 child nodes or 16 childnodes. A node has 16 child nodes when the router partitions that node'sregion into 16 sub-regions. Conversely, a node does not have child nodeswhen its corresponding region is not partitioned.

In some embodiments, the router 3900 defines a slot data structure torepresent each node in a slot-hierarchy. FIG. 47 presents one such datastructure 4700 for a slot. This data structure specifies the coordinates4710 of the slot. It also includes a reference (e.g., a pointer) 4720 toa list 4740 of circuit modules in the slot. This list 4740 includes oneor more references (e.g., one or more pointers) 4745 to one or morecircuit modules 4800 in the slot.

The slot data structure 4700 also includes a reference to a list 4730 ofslot-nets of the slot. The list includes references 4735 to slot-netdata structures 4500. In the embodiments described below, the slot datastructure does not have references to its child slots. Some of theseembodiments order the slots in a pre-specified order on a list, andbased on this order, these embodiments identify corresponding child andparent slots. The slot data structure 4700 also includes a field 4725that specifies the slot's unique identifier.

4. Circuit Modules.

FIG. 48 illustrates the data structure 4800 of a circuit module. Thisdata structure stores the orientation (4805) and the position (4810) ofthe circuit module. It also includes a reference 4815 to the circuitmacro 4820, which contains a description of the circuit module. Forinstance, the circuit macro refers to data structures 4825 for obstacleswithin the circuit module. The obstacle data structures specifyinformation about the obstacles, such as the layer (4830) and shape(4835) of the obstacles.

C. Initializer.

FIG. 49 illustrates a process 4900 performed by the initializer at thestart of the routing operation. Before this process starts, the routertypically has received a placed net list, technology definition(including number of layers, preferred wiring direction for each layer,routing pitch for each layer, etc.), and the number of tracks for thelowest level slots (i.e., for the Gcells).

The process initially calculates (at 4905) the number of recursions fromthe track data for the lowest-level slots, pitch per track, and size ofthe design. To do this, the process initially multiplies the track databy pitch per track to obtain the dimensions of the lowest level slots.It then repeatedly divides the design size by 4, while the resultingvalue is bigger than the computed dimensions. With each division, itincrements a level counter by one. The process stops the division andthe counting, once the resulting value would be smaller than thecomputed dimensions.

Based on the number of levels, the process then computes (at 4910) thenumber of slots. At each level there are 16 children. Hence, the totalnumber of slots is the sum of 16**n, where n varies from 0 to level. Atthis stage, the process also creates a list of all slots.

Next, the process instantiates (at 4915) slot data structures for theslots at all the recursion levels. The process then (at 4920) (1) foreach net, identifies all the slots that the net traverses, and (2) foreach identified slot, instantiates a slot-net data structure to storethe net's configuration in that slot.

FIG. 50 illustrates a process 5000 that some embodiments use to perform4920. Specifically, this process is a recursive process that starts atthe top-level slot and it is performed for each net. Each time thisprocess is called it receives a slot and a net. As shown in FIG. 50,this process 5000 initially computes (at 5005) the bounding box of thereceived slot.

It then determines (at 5010) whether any pin of the received net iscontained in the bounding box of the received slot. If not, the processends. If so, the process creates (at 5015) a slot-net record thatcontains the pin distribution of the net for the current slot. Inaddition, the process recursively calls (at 5020) itself for thereceived net and each child-slot of the current slot. The process 5000then ends.

After the process 4900 instantiates slot-net data structures to storethe net configurations in the slots, the process 4900 adds (at 4925)each circuit module to the table of modules for the slots that itintersects, and then ends. FIG. 51 illustrates a process 5100 that someembodiments use to perform 4925. Specifically, this process is arecursive process that starts at the top-level slot and it is performedfor each circuit module. Each time this process is called, it receives aslot and a circuit module. As shown in FIG. 51, this process 5100initially computes (at 5105) the bounding box of the received slot.

The process 5100 then computes (at 5110) the bounding box of thereceived circuit module. It then determines (at 5115) whether the twobounding boxes intersect. If not, the process ends. If so, the processadds (at 5120) the module to the list of circuit modules incident to thecurrent slot. In addition, the process recursively calls (at 5125)itself for the received module and each child-slot of the current slot.The process 5100 then ends.

D. Slot Manager.

FIG. 52 illustrates a process 5200 performed by the slot manager 3925after the initializer 3915 completes its operation. Initially, theprocess 5200 sets (at 5205) the current level as the top-level slot.Next, the process defines the capacity of the routing paths within theslots of the current level. In some embodiments, the process receives,or can retrieve from a storage structure, the routing path capacitiesfor the first level, and thereafter computes the routing path capacitiesmathematically based on the known geometric relationship between thechild slots and the parent slots. In other embodiments, the process inreal-time calculates the routing path capacities for all the levels.However, some of these embodiments still compute the routing pathcapacities of some recursion levels from those of other levels.

As mentioned above, some embodiments calculate the capacities of eachpath at a particular recursion level from the size of the edgeorthogonal to the path. For instance, some embodiments calculate thecapacity of each particular path by dividing the size of thecorresponding orthogonal edge (i.e., the size of the edge orthogonal tothe particular path) with the pitch of metal layer corresponding to theparticular path. Some embodiments define the pitch of a metal layer asthe line-to-via pitch. Some embodiments define the line-to-via pitch asthe minimum required distance between interconnect lines on that metallayer, plus ½ the width of the line, plus ½ the width of the viaincluding the metal overlap.

As mentioned above, in some embodiments, the capacities of the diagonalpaths differ from the capacities of the Manhattan paths. This can bemodeled by the virtue of the differing size of the edges that areorthogonal to the diagonal and Manhattan paths. It can also be modeledby having the pitch dependent on the type of interconnect line (e.g.,having the pitch for diagonal lines differ from the pitch for theManhattan lines). It can further be modeled by having the pitchdependent on the layer. For instance, in some embodiments, the pitch ofthe −45° metal layer differs from the pitch of the 45° metal layer.

At 5215, the process sets the current slot as the first slot at thecurrent level. As further described below, the process 5200 examines theslots at the current level in sequence. However, one of ordinary skillwill realize that other embodiments might examine the slots in anotherorder. For example, some embodiments might examine the most congestedslots first.

It then directs (at 5220) the solver to select routes for all nets inthe current slot at the current level. Once the solver selects therouting paths and stores these paths in the slot-net data structurefield 4515, the slot manager determines whether the current level is thelast recursion level.

If not, the process directs (at 5230) the propagator to define thepropagation of the selected routes into the child slots of the nextlower recursion level (i.e., into the child slots of the child slots ofthe current slot). For slots that are after the top-level slot, thepropagator also performs a follow-up propagation operation thatpropagates the paths specified by the propagator at the previous routinglevel one level further down. In defining the propagation into the nextlower recursion level, the propagator might modify the net'sconfiguration in the current child slots by adding virtual pins in thechild slots of the current child slots.

If the process determines that the current slot is at the last recursionlevel (i.e., the current slot is a leaf slot), it directs (at 5235) thesaver to link the path structures of each net's route in the currentleaf slot to their respective net's main data structures. As mentionedabove, the saver also links to the main net data structures the pathdata structures of the propagation paths that the propagator specifiesfor a parent slot of a leaf-level slot (i.e., for a grandparent slot ofa Gcell). These propagation paths include paths that the propagatoridentified (1) for the routing paths specified by the solver and (2) forthe routing paths specified by the propagator at the previous routinglevel. In this manner, the path data structures linked to a net's maindata structure collectively represent the final route for the net thatthe router specifies. In some embodiments, such a route is a globalroute for a net.

From 5230 and 5235, the process transitions to 5240, where it determineswhether it has examined the last slot at the current level. If not, theprocess selects (at 5245) another slot at the current level and returnsto 5220 to call the solver for this slot. Otherwise, the processdetermines (at 5250) whether it is at the last recursion level. If not,the process selects the next recursion level, and returns to 5210 tospecify more detailed routes for the nets at the next lower recursionlevel. When the process determines (at 5250) that it is at the lastrecursion level, it ends.

E. Solver.

As discussed above, the solver 3930 is responsible for (1) enumeratingone or more routes for each net, (2) directing an LP/ILP solver toselect a route for each net, and (3) saving the selected results in theslot-net data structures of the current slot. FIG. 53 illustrates aprocess 5300 performed by the solver. In some embodiments, this processstarts when the slot manager calls the solver and supplies it with aslot to route.

The process 5300 initially predicts (at 5305) congestion of resourcesfor each path in the slot. One manner for predicting the congestion ofthe paths will be described below by reference to FIGS. 54 and 55. Theprocess next identifies (at 5310) one or more routes for each net in thesupplied slot. One manner for identifying routes for the nets in thecurrent slot will be described below by reference to FIGS. 57-60.

After identifying one or more routes for each net in the current slot(i.e., for each net that has a slot-net structure linked to the currentslot's data structure), the process 5300 assigns (at 5315) a wirelengthcost to each retrieved tree by factoring propagation into the next lowerrecursion level. In some embodiments, the process uses a greedytechnique to account for this propagation. One manner for assigningcosts for each retrieved tree will be described below by reference toFIGS. 64.

Once the solver assigns wirelength costs to the enumerated potentialroutes, the solver formulates (at 5320) the problem for the LP solver3945, and the LP solver solves (at 5325) the LP problem. One manner forformulating and solving the LP problem will be described below insubsection VI.E.4.

After 5325, the process 5300 converts (at 5330) the LP solution to aninteger LP (“ILP”) solution. Some embodiments use randomized rounding toperform this conversion. Randomized rounding is a known technique, andnumerous examples of this technique can be found in the literature,e.g., one such reference is disclosed in Randomized Algorithm, by RajeevMotwani and Prabhakar Raghavan, Cambridge University Press (1995, 1997).

One example of a randomized rounding process is as follows. First, theprocess maps the scores returned by the LP solver to probabilitiesbetween 0 and 1. For instance, when the LP solver returns real solutionsbetween 0 and 1, a one-to-one mapping exists between the returnedsolutions and probabilities between 0 and 1. Second, the roundingprocess generates a random numbers between 0 and 1 for each net. Third,the rounding process selects the net's solution that is mapped to thegenerated random number for the net. Fourth, the rounding processmeasures the quality of the set of selected routes for the nets based oncertain objective function or functions (such as those used by the LPsolver). Fifth, the rounding process iteratively repeats the second tofourth operations until the solution space has been sufficientlyexplored. Sixth, the process selects the set of routes that resulted inthe best quality score.

Based on the set of routes selected at 5330, the process stores (at5335) a 42-bit selected route string in each slot-net data structure ofthe current slot. This 42-bit string specifies the paths in the currentslot that the selected route of the net takes. The process then ends.

1. Predicting Remaining Path Capacities.

As mentioned above, the process 5300 predicts (at 5305) the congestionof path resources in the current slot. In some embodiments, the processspecifies the path congestions by estimating the remaining capacity ofeach path in the slot. For instance, in some embodiments, the processcomputes path capacities by initially (1) estimating the unblockedcapacity of each path, (2) estimating the use of each path, and (3)subtracting each path's use estimate from its unblocked-capacityestimate. One manner for estimating the unblocked path capacities willbe described below by reference to FIG. 54, while one manner forestimating the path use will be described below by reference to FIG. 55.

a. Estimating Unblocked Capacity of Each Path.

FIG. 54 illustrates a process 5400 for estimating the unblocked capacityof each path in the current slot. Initially, this process allocates (at5402) a data structure with 42-fields of floating point numbers. Eachfield is for storing the unblocked capacity of one of the 42 paths. At5402, the process also initializes each of path's field in the datastructure to the default capacity value for the path.

At 5404, the process selects a circuit module in the current slot's listof circuit module. The process then retrieves (at 5406) the circuitmacro for the selected circuit module. It then selects (at 5408) anobstacle on the circuit macro, and computes (at 5410) the bounding boxof the selected obstacle by using the location of the circuit module.

Next, the process (at 5412) selects one of the 42 paths of the currentslot. It then determines (at 5414) whether path selected at 5412 is onthe same layer as of the obstacle selected at 5408. If the selectedpath's layer matches the selected obstacle's layer, the processcalculates (at 5422) the bounding box of the selected path. Differentembodiments define bounding boxes for paths differently. For instance,some embodiments define the bounding boxes for both Manhattan andnon-Manhattan paths as rectangular halos about the paths. Under such anapproach, the rectangular halo about a diagonal path is positioneddiagonally with respect to the x-y coordinate axis. Other embodimentsmight define the bounding box of a diagonal path differently. Forinstance, some embodiments might define such a bounding box in terms offour rectangular halos (four bounding boxes) that encompass the fourManhattan edges about the diagonal path (e.g., the bounding box ofdiagonal path 26 would include four boxes that encompass edges E1, E4,E13, and E14).

The process then calculates (at 5424) the area of the bounding box ofthe path. The process next identifies (at 5426) the intersection of theselected path's bounding box and the selected circuit module's boundingbox, and calculates (at 5428) the area of this intersection.

It then computes (at 5430) an obstruction factor by dividing thecalculated intersection area by the calculated path area. The processnext multiplies (at 5432) the obstruction factor by the default pathcapacity to produce an estimate of the number of tracks of the pathobstructed by the obstacle. The process then subtracts (at 5434) theresult of this multiplication from the path's current unblockedcapacity, which is stored for the path in the 42-field data structure.The process next transitions to 5416, which is described below.

The process also transitions to 5416 from 5414 when the selected path'slayer is not the same as the selected obstacle's layer. At 5416, theprocess determines whether it has examined all the paths in the currentslot. If not, the process returns to 5412 to select another path of thecurrent slot.

However, if the selected path is the last path of the current slot, theprocess determines (at 5418) whether it has examined all the obstaclesof the circuit module selected at 5404. If not, the process transitionsto 5408 to select another obstacle of the selected circuit module.Otherwise, the process determines (at 5420) whether it has examined allthe circuit modules in the current slot. If not, the process transitionsto 5404 to select another circuit module in the current slot.

The process 5400 ends when it has examined all the circuit modules inthe current slot. At this stage, the 42-field data structure specifiesthe unblocked capacities of the 42 paths in the current slot.Specifically, at this stage, each of the 42 fields specifies theunblocked capacity of one of the 42 paths.

b. Path Use Estimation.

FIG. 55 illustrates a process 5500 for estimating the use of each pathin a slot. This process is a recursive process that computes the usageof each path in the current slot in terms of three usage components. Onepath-usage component represents path usage due to routes between currentslot's child slots. Another component represents path congestion due toroutes in the current slot's child slots. The third component accountsfor the effect of vias on path congestion. One of ordinary skill willunderstand that other embodiments compute path usage differently. Forinstance, for each net that is in only one child slot of a leaf slot,some embodiments also include a token path-usage value for each pathincident on the child slot that contains the net.

The process 5500 starts each time it receives a current slot. As shownin FIG. 55, the process 5500 initially determines (at 5502) whether thecurrent slot is a leaf slot. If so, the process transitions to 5512,which will be described below. If not, the process performs 5504 to 5510to compute the usage values due to the routes in the current slot'schild slots. Specifically, at 5504, the process selects one of the childslots of the current slot. The process then estimates (at 5506) the useof each path of each child slot of the current slot. In someembodiments, the process does this by recursively calling itself foreach of the child slots.

The process next determines (at 5508) whether the child slot selected at5504 is the last child slot. If not, the process selects (at 5504)another child slot and estimates (at 5506) the path-usage in thenewly-selected child slot. Otherwise, the process transitions to 5510 tocalculate the path-usage component due to the congestion in the currentslot's child slots.

In some embodiments, the process stores the path-usage values calculatedat 5510 in a data structure (e.g., an array) with 42-fields for storingthe usage values for the 42 paths in the current slot. The processreceives this data structure with the current slot in some embodiments,while in other embodiments, the process 5500 does not receive such adata structure but rather initializes the data structure when it starts.

At 5510, the process calculates path-usage component due to thecongestion in the child slots. For instance, the process can define acomponent usage value for path 1 between child slots 1 and 2 in terms ofthe congestion within child slots 1 and 2 via a formula such as

path_1_use =   [(0.75) + (0.25) * (1/(Number  of  recursion  levels − Current  Level))] * (1/2) * (1/2 * (path[1][2] + path[1][5] + path[1][8] + path[1][11]) + 1/3 * (path[1][1] + path[1][4] + path[1][7] + path[1][10]) + 1/6 * (path[1][0] + path[1][3] + path[1][6] + path[1][9]) + 1/2 * (path[2][0] + path[2][3] + path[2][6] + path[2][9]) + 1/3 * (path[2][1] + path[2][4] + path[2][7] + path[2][10]) + 1/6 * (path[2][2] + path[2][5] + path[2][8] + path[2][11])),where path[i][j] refers to the usage of path j of child slot i. Similarequations can be used to define analogously the component usage valuesfor the other 41 paths in the current slot.

The above equation only examines in the child slots the horizontal pathsline that are in line with path 1. Specifically, it examines the path1's component usage value in terms of all the horizontal paths (i.e.,paths 0-11) of child slots 1 and 2. The summation of the usage values inboth child slots 1 and 2 is multiplied by ½ to reflect that the capacityof path 1 in the current slot is equally influenced by the capacities ofthe paths in child slots 1 and 2.

The multipliers ½'s, ⅓'s and ⅙'s are used in the summation for bothchild slots 1 and 2 for the following reasons. The objective is to guesshow many wires can be pushed through a path. Some of these wires willterminate immediately after crossing the path, while some will cross theentire width of the slot incident to the path. It is assumed that therewill be a uniform distribution of “endpoints” of the wires using thepath, such that for propagate 0 of path 1 ¼ will terminate in slot 0 ofchild slot 2, ¼ will terminate in slot 1 of child slot 2, ¼ in slot 2 ofchild slot 2 and ¼ in slot 3 of child slot 2 and beyond. This means that¾ of the wires that use the path 1 will also use path 0 of child slot 2,2/4 will use path 1 in child slot 2, and ¼ will use path 3 in child slot2—which gives a ratio of 3:2:1 (or 3/6, 2/6, ⅙) of relative impact ofthe usages of these 3 paths on the estimated use of the propagated path.

Also, the summation of usage values in child slots 1 and 2 is multipliedby [(0.75)+(0.25)*(1/(Number of recursion levels−Current Level))]. Thismultiplication is based on an assumption that most nets routes' includea single path connecting two real pins. If a uniform distribution ofpins is assumed in the grandchild slots, then ¾^(th) of the routes usinga given path will see congestion from the nets wholly contained in eachchild slot. As the router moves down the hierarchy, a greater percentageof the routes traverse entire grandchild slots, and hence more nets willsee the entire congestion in the grandchild slots, which therebyjustifies increasing the multiplier to 1.

From 5502 or 5510, the process transitions to 5512. The process performsoperations 5512 to 5528 to compute the component usage values due to theroutes between the current slot's child slots. The process computesthese component values in terms of the probabilistic-Steiner-treecontributions described above.

At 5512, the process selects a net. The process then retrieves (at 5514)the selected net's pin configuration in the current slot. It nextidentifies (at 5516) the probabilistic Steiner-tree values for theretrieved pin configuration. As mentioned above, FIG. 28 illustrates theprobabilistic Steiner-tree values for the pin configuration of net 505illustrated in FIG. 5. Some embodiments precompute the probabilisticSteiner-tree values, as described above by reference to FIG. 26. Otherembodiments, however, generate these values during the path-useestimation process 5500.

The process then adds (at 5520) each path's probability values to thepath's usage value in the 42-field data structure. Next, the processperforms 5522-5530 to compute the token usage value to account for theeffect of vias for the net on the path congestion.

When a net has one or more pins in the child slots of the current slot,these pins are typically on the lower metal layers. Accordingly, viaswill need to be added to connect some of these pins to the specifiedpaths for the net. The addition of each via, in turn, will increase thepath congestion.

At 5522, the process selects a child slot that contains one of the pinsof the net selected at 5512. This net has one or more routes, with eachroute using one or more paths. Hence, at 5524, the process selects oneof the route paths incident on the child slot selected at 5522. It thenincrements (at 5526) the selected path's usage value by a token amount.In some embodiments, the token amount is 0.5/(Number of Recursionlevels−Current Recursion Level).

The process then determines (at 5528) whether it has examined all thepaths (of all the trees of the selected net) that are incident on theselected child slot. If not, the process selects (at 5524) another pathincident on the selected child slot and then increments (at 5526) theselected path's usage value by the token amount.

On the other hand, if the process determines (at 5528) that it hasexamined the last path incident on the selected child slot, the processdetermines (at 5530) whether it has examined the last child slot with apin for the selected net. If not, the process returns to 5522 to selectanother child slot that has a pin for the selected net. Otherwise, theprocess determines (at 5532) whether it has examined the last net in thecurrent slot. If not, the process transitions back to 5512 to selectanother net and to perform the subsequent operations for this net. Theprocess ends when it determines that it has examined the last net at5532.

2. Identifying Routes for Each Net in the Current Slot

After estimating (at 5305) the remaining capacity of each path in thecurrent slot, the process identifies (at 5310) one or more routes foreach net in the current slot. The embodiments described below initiallyuse each net's configuration with respect to the current slot toidentify one or more routes for each net.

These embodiments then generate fake configurations for some or allnets, and identify additional routes for the nets based on the generatedfake configurations. Some embodiments use two different approaches togenerate fake configurations for a net. One approach adds fake pins to anet's configuration. This approach is described below by reference toFIGS. 56-58. The second approach breaks a net's configuration into twoor more configurations and adds fake pins to the new configurations.This approach is described below by reference to FIGS. 60 and 59.

a. Identifying Routes for Each Net Configuration and Generating DetourPossibilities By Adding Fake Pins to the Net Configurations.

FIG. 56 illustrates a process 5600 for identifying routes for each netconfiguration and generating detour possibilities by adding fake pins tothe net configurations. As shown in this figure, the process 5600initially selects (at 5602) a net in the current slot. At 5604, theprocess (1) uses the net's configuration in the current slot to identifyroutes for the selected net, and (2) stores the identified routes forthe selected net in a variable in the solver. The process 5600identifies trees for the particular net configurations based on one ofthe approaches described above in Section V.

After identifying and storing the routes based on the selected net'sconfiguration, the process performs some or all of the operations 5606to 5668 to determine whether it needs to generate detour routes for theselected net, and if so, to generate these detour routes by adding oneor two fake pins.

The process 5600 generates detour routes for a selected net where allthe optimal routes identified for the net at 5604 use one or more pathsthat are “at risk”. A path is “at risk” if the estimated congestion(path-use plus blockages) is near or over the path's capacity. Someembodiments determine whether a path is “at risk” by determining whetherthe path's remaining capacity (which was computed at 5305) is less thana threshold amount. Sub-optimal routes can be generated for a varyingnumber of nets by varying the threshold at which a path is defined to be“at risk.”

FIGS. 57 and 58 provide illustrative examples of how sub-optimal detourroutes are generated by adding one or two fake pin configurations.Specifically, FIG. 57 illustrates a sub-optimal route 5725 for a netthat has two pins 5710 and 5715 in child slots 8 and 11. Thissub-optimal route is generated by adding a fake pin 5705. Thissub-optimal route 5725 avoids horizontal path P7 (between child slots 9and 10), which is congested due to obstacle 5720. Adding virtual pin5705 to the pin distribution of the net results in a new pinconfiguration. The optimal route for this new pin configuration providesa sub-optimal route for the original net having pins 5710 and 5715. Thissub-optimal route does not use “at risk” path 7.

FIG. 58 illustrates an example where two fake pins 5805 and 5810 havebeen added to a net that has pins 5815 and 5820. These two fake pinsgenerate a sub-optimal route 5830 that avoids paths 7 and 33 that areblocked and congested by obstacle 5825.

The process 5600 of FIG. 56 generates detour routes by (1) adding oneand then two fake pins to the net configurations, and (2) identifyingthe best optimal routes for the resulting pin configurations. Eventhough this process at most adds two fake pins to a net's configuration,one of ordinary skill will realize that other embodiments add more fakepins to the net configurations in order to identify useful detour routesfor some or all the nets.

At 5606, the process selects one of the routes identified at 5604. Itthen identifies (at 5608) one of the paths of the route selected at5606. At 5610, the process determines whether the remaining capacity ofthe path selected at 5608 is less than the threshold capacity value. Theremaining capacity of the path was computed at 5305.

If the process determines (at 5610) that the path's remaining capacityis less than its threshold capacity value, the process flags (at 5612)the route selected at 5606 as unusable, and then transitions to 5616,which will be described below. If not, the process determines (at 5614)whether it has examined all the paths of the selected route. If it hasnot examined all the paths, it transitions back to 5608 to selectanother path of the selected route. Otherwise, the process transitionsto 5616.

At 5616, the process determines whether it has examined all the routesidentified at 5604. If not, the process transitions back to 5606 toselect another of the identified routes for the selected net. Otherwise,the process determines (at 5618) whether it marked all the identifiedroutes for the selected net as unusable. If not, the net has one or moreroutes that do not use any “at risk” paths, and hence the process doesnot generate fake configurations for this net. The process thendetermines (at 5620) whether it has examined all the nets in the currentslot. If it has examined all the nets, the process ends. Otherwise, theprocess transitions from 5620 to 5602 to select another net in thecurrent slot.

If the process determines (at 5618) that all the identified routes forthe selected net are unusable, the process selects (at 5622) a childslot of the current slot. For the selected net, the process thengenerates (at 5624) a fake pin configuration that indicates the net hasa pin in the child slot selected at 5622. In some embodiments, theprocess generates this fake pin configuration by duplicating theselected net's actual pin configuration in the current slot, andensuring that the duplicated pin configuration indicates a pin for thechild slot selected at 5622. In the example illustrated in FIG. 57, theprocess generates a fake configuration 0000100101000000 by adding a “1”for the 6^(th) child slot to the original configuration0000100100000000.

The process then identifies (at 5626) routes for the fake pinconfiguration generated at 5624. The process can identify these routesfor the pin configuration by using any one of the methods discussedabove in Section V. Next, the process selects (at 5628) one of theroutes identified at 5626. The process then determines (at 5630) whetherthe selected route is usable. The process makes this determination byperforming usability-checking operations similar to 5608-5616, whichwere described above. If process determines (at 5630) that the routeselected at 5628 is not usable, the process transitions to 5634, whichwill be described below. If the selected route is usable, the processrecords (at 5632) for the generated fake configuration the selectedroute's cost, and then transitions to 5634.

At 5634, the process determines whether it has examined all the routesidentified at 5626 for the generated fake configuration. If not, theprocess transitions back to 5628 to select another identified route.Otherwise, the process determines (at 5636) whether it has generated afake pin configuration for all the child slots of the current slot. Ifnot, the process returns to 5622 to select another child slot.

Otherwise, the process identifies (at 5638) the fake pin configuration,if any, that resulted in the useable route with the best cost recordedat 5632. If a configuration is identified at 5638, the process thenidentifies (at 5640) all the useable routes for the pin configurationidentified at 5638, and adds these routes to the set of possible routingsolutions for the current net.

Next, the process performs 5642-5668 to generate routes for fakeconfigurations that contain up to 2 fake pins. Specifically, at 5642,the process selects a child slot of the current slot. The processduplicates (at 5644) the selected net's actual pin configuration in thecurrent slot. It then ensures (at 5646) that the duplicated pinconfiguration indicates a pin for the child slot selected at 5642. Inthe example illustrated in FIG. 58, the process generates an initialfake configuration 0000100101000000 by adding a “1” for the 6^(th) childslot to the original configuration 0000100100000000.

At 5648, the process then selects a child slot other than the oneselected at 5642. It then generates (at 5650) a fake pin configurationthat indicates the net has a pin in the child slot selected at 5648. Insome embodiments, the process generates this fake pin configuration byduplicating the pin configuration identified at 5646, and ensuring thatthe duplicated pin configuration indicates a pin for the child slotselected at 5648. In the example illustrated in FIG. 58, the processgenerates a final fake configuration 0000100101100000 by adding a “1”for the 5^(th) child slot to the initial fake configuration0000100101000000.

The process then identifies (at 5652) routes for the fake pinconfiguration generated at 5650. As at 5604 and 5626, the process canidentify these routes for the generated pin configuration by using anyone of the methods discussed above in Section V.

Next, the process selects (at 5654) one of the routes identified at5652. The process then determines (at 5656) whether the selected routeis usable. The process makes this determination by performingusability-checking operations similar to 5608-5616, which were describedabove. If the route selected at 5654 is not usable, the processtransitions to 5660, which will be described below. If it is usable, theprocess records (at 5658) for the generated fake configuration theselected route's cost, and then transitions to 5660.

At 5660, the process determines whether it has examined all the routesidentified at 5652 for the fake pin configuration generated at 5650. Ifnot, the process transitions back to 5654 to select another identifiedroute. Otherwise, the process determines (at 5662) whether it hasgenerated a fake pin configuration for all the child slots other thanthe child slot selected at 5642. If not, the process returns to 5648 toselect another child slot other than the one selected at 5642.

Otherwise, the process determines (at 5664) whether it has examined allthe child slots as potential first fake pins. If not, the processreturns to 5642 to select another child slot. When the processdetermines (at 5664) that it has examined all the child slots aspotential first fake pins, the process identifies (at 5666) the fake pinconfiguration, if any, that resulted in the useable route with the bestcost recorded at 5658. If a configuration was identified at 5666, theprocess then identifies (at 5668) all the useable routes for the pinconfiguration identified at 5666, and adds these routes to the set ofpossible routing solutions for the current net.

From 5668, the process transitions to 5620. At 5620, the processdetermines whether it has examined all the nets in the current slot. Ifit has examined all the nets, the process ends. Otherwise, the processtransitions from 5620 to 5602 to select another net in the current slot.

b. Breaking Net Configurations into Smaller Pin Configurations andAdding Fake Pins to the Smaller Pin Configurations

In some instance, simply adding fake pins to a net configuration doesnot result in the best sub-optimal route. Such a route can sometimes begenerated by (1) generating two or more pin configurations from a net'spin configuration, (2) identifying fake configurations for the generatedpin configurations, (3) identifying routes for the configurations, and(4) combining the resulting routes to find one or more sub-optimalroutes. Such an approach is especially useful in situations where thecongested path is between 2 adjacent “real” pins.

FIG. 59 illustrates an example of such an approach. In this example, anet has two pins 5905 and 5910. If a fake pin 5915 is added to theoriginal net configuration, the route for the resulting netconfiguration would use paths P6 and P21. However, such a route wouldnot be useable since obstacle 5920 completely obstructs path P6. A moreideal route that uses paths 21 and 36 can be obtained by (1) splittingthe pin configuration into two, one that contains pin 5905 and one thatcontains pin 5910, and (2) adding the fake pins 5915 to both of theresulting pin configurations.

FIG. 60 illustrates a process 6000 that identifies additional routes fora net configuration. This process generates two pin configurations fromthe net's pin configuration, identifies fake configurations for both thegenerated pin configurations, identifies routes for the fakeconfigurations, and combines the resulting routes. Some embodimentsperform this process for each net in the current slot, while otherembodiments only perform this process for some of the nets, such asthose for which the process 5600 was not able to find useable routes.

As shown in FIG. 60, the process 6000 starts by identifying (at 6002)one or more routes for a net in the current slot. The process canidentify these routes based on the net's pin configuration by using anyone of the methods discussed above in Section V. The process thenidentifies (at 6004) the child slot that has the most number of paths ofthe identified routes incident upon it. The process then defines (at6006) two bitsets, bset1 and bset2. In some embodiments, each bitset has16-bits, all of which are initially defined to be zero.

Next, at 6008, the process sets to 1 the first bitset's bitcorresponding to the child slot identified at 6004. At 6008, the processalso sets to 1 the second bitset's bit or bits that correspond to theremaining child slots that contain pins of the current net. At 6010, theprocess initializes two variables, which are the Best_Length variableused to measure the best length of a number of solutions, and theBest_Detour variable used to identify the solution that resulted in thebest length. The Best_Length variable is initialized to a large value,while the Best_Detour variable is initialized to null.

At 6012, the process selects one of the current slot's child slots. Itthen determines (at 6014) whether the current net's pin configurationhas the selected child slot's corresponding bit set to 1 (i.e., whetherthe current net has a pin in the selected child slot). If so, theprocess determines (at 6016) whether it has tried to generate fakeconfigurations for each child slot of the current slot. If it has notexamined all the child slots of the current slot, the process returns to6012 to select another child slot. If it has, the process transitions to6040, which will be described below.

If the process determines (at 6014) that the bit corresponding to theselected child slot is not set to 1 in the current net's pinconfiguration, the process generates (at 6018) two duplicated bitsets,biset1 c and bitset2 c, from the two bitsets, bitset1 and bitset2. Ineach duplicate bitset, the process then sets (at 6020) to 1 the bit thatcorresponds to the selected child slot.

Next, the process identifies (at 6022) one or more routes for each ofthe duplicated, modified bitsets. The process can identify these routesfor the duplicated, modified bitsets by using any one of the methodsdiscussed above in Section V. The process then selects (at 6024) one ofthe routes for the first duplicated, modified bitset (i.e., for bitset1c), and selects (at 6026) one of the routes for the second duplicated,modified bitset (i.e., for bitset2 c). At 6028, the process thendetermines whether the two selected routes overlap (i.e., whether thetwo solutions share one or more routing paths between the child slots).If so, the process transitions to 6036, which will be described below.

If not, the process calculates (at 6030) the length of a route thatwould result by combining the two routes selected at 6024 and 6026. Insome embodiments, the process calculates this length by summing thelengths of the two routes selected at 6024 and 6026. At 6032, theprocess determines whether the length calculated at 6030 is less thanthe current Best_Length. If not, the process transitions to 6036, whichwill be described below.

When the length calculated at 6030 is less than the current Best_Length,the two routes selected at 6024 and 6026 represent the best solutionthat the process 6000 has seen thus far. Accordingly, at 6034, theprocess defines the Best_Length equal to the length computed at 6030. At6034, the process also generates a new route as the combination of thetwo routes selected at 6024 and 6026, and defines the Best_Detour as thegenerated new route. From 6034, the process transitions to 6036.

At 6036, the process determines whether it has examined all the routesidentified (at 6022) for the second duplicated, modified bitset (bitset2c) with the route that was selected at 6024 for the first duplicated,modified bitset (bitset1 c). If not, the process returns to 6026 toselect another route for the second bitset2 c. Otherwise, at 6038, theprocess determines whether it has examined all the routes identified (at6022) for the first duplicated, modified bitset (bitset1 c). If not, theprocess returns to 6024 to select another route for the first bitset1 cto examine.

When the process determines (at 6038) that it has examined all theidentified routes for the first duplicated, modified bitset (bitset1 c),it determines (at 6016) whether it has tried to generate fakeconfigurations for each child slot of the current slot. If it has, theprocess (at 6040) adds the solution (if any) that the process identifiedas the Best_Detour to the current net's solution pool, and then ends. Onthe other hand, if the process has not generated fake configuration foreach child slot, the process returns to 6012 to select another childslot.

3. Assigning Costs for the Potential Routes

After identifying (at 5310) one or more routes for each net in thecurrent slot, the process 5300 assigns (at 5315) a wirelength cost toeach retrieved tree by factoring propagation into the next lowerrecursion level. In some embodiments, the cost of each route includesthe following three component costs: (1) the wirelength cost of theroute's path or paths that connect the child slots of the current slot,(2) the path propagation cost of the route's path or paths into thechild slots, and (3) the cost in each child slot after selecting thepath propagations.

FIG. 64 illustrates a process for calculating the cost of each route interms of these three component costs. Before explaining this process,the conceptual framework used by this process is explained by referenceto FIGS. 61-63. These figures illustrate how some embodiments modelpropagation of a higher-level route into lower level child slots.Specifically, FIG. 61 illustrates that any horizontal or vertical pathbetween the current slot's child slots can propagate down into the slotsof the child slots along one of 10 propagation paths.

FIGS. 62 and 63 illustrate two different ways for modeling thepropagation of a 45° diagonal path into the lower level child slots. Themodel that FIG. 62 illustrates provides 7 propagation possibilities fora 45° diagonal path. On the other hand, the model illustrated in FIG. 63provides for 19 propagations for a 45° diagonal path between twodiagonally-positioned child slots 6305 and 6310. This is because themodel illustrated in FIG. 63 only specifies the path propagations alongthe edges of child slots 6305 and 6310, which thereby allows a pathpropagation along an edge of one of the child slots to pair up withanyone of three path propagations along the corresponding edge of theother child slot. For instance, as shown in FIG. 63, the propagation6315 along edge 6320 can be paired up with anyone of the propagations6325, 6330, and 6335 along edge 6340. Under this approach, a diagonalpath between slots 6305 and 6310 can have 19 propagations, where (1) 9of the propagations are defined by pairing up three path propagationsalong edge 6320 with three path propagations along edge 6340, (2) 9 ofthe propagations are defined by pairing up three path propagations alongedge 6345 with three path propagations along edge 6350, and (3) 1 of thepropagation 6355 is defined between the top left hand corner of slot6310 and the bottom right hand corner of slot 6305.

As shown in FIG. 64, the process 6400 initially selects (at 6402) a net.It then selects (at 6404) one of the routes identified (at 5310) for theselected net. The process next initializes (at 6406) theselected-solution's Total_Cost to 0. It then needs to identify the pathcost of the route selected at 6404. In some embodiments, one of theLUT's 3965 stores pre-tabulated wirelength costs for each netconfiguration. In these embodiments, the pre-tabulated wirelength costof a selected tree can be retrieved from the LUT when the tree is addedto the solution set of the net. Alternatively, the process 6400 can usethe pin configuration that resulted in the identification of theselected tree for the current net to retrieve the tree's pre-tabulatedwirelength cost from the LUT.

In the embodiments described below, however, the process 6400 computesthe path cost of the selected route by performing 6408-6412.Specifically, at 6408, the process selects a path of the selected route.It then increments (at 6410) the selected-solution's Total_Cost by thecost of the path selected at 6408. Some embodiments define a path's costpurely based on the relative length of the path compared to other paths.For instance, some embodiments assign a path-cost of 1 for eachhorizontal or vertical path between slots (e.g., for each path P0-P23 inFIG. 12) and a path-cost of 1.4 for each diagonal path between slots(e.g., for each paths P024-P041). Other embodiments assign a path costof 5 for each horizontal or vertical path between slots (e.g., for eachpath P0-P23 in FIG. 12) and a path cost of 7 for each diagonal pathbetween slots (e.g., for each paths P024-P041).

Other embodiments might define the path-costs not purely based on therelative path lengths. To achieve a certain objective (e.g., encourageuse of the lower-layer wiring or discourage use of vias), someembodiments might cost the paths that traverse the higher levels moreexpensive than their relative length cost compared to the lower-layerwiring. For example, some embodiments might assign a path-cost of 1 foreach horizontal or vertical path between slots and a path-cost greaterthan 1.4 for each diagonal path between slots.

At 6412, the process determines whether it has examined all the selectedroute's paths. If not, the process returns to 6408 to select anotherpath for costing. When the process determines (at 6412) that it hasexamined all the selected route's paths, it determines (at 6414) whetherthe current slot is a leaf-level slot. If so, the process transitions to6428, which will be described below.

If the process determines that the current slot is not a leaf-levelslot, the process accounts for the wirelength cost in the child slots.The process uses a greedy technique to factor the propagation of theselected route into the child slots. Specifically, the process orders(at 6416) each of the selected tree's paths by the number of anchors ofthat path. Some embodiments define an anchor as a pin in either childslot upon which the path is incident. In these embodiments, a path hasat most two anchors. Other embodiments might define an anchor as thenumber of pins in the slots of a child slot; under such an approach, apath can have up to 32 anchors, when it has 16 pins in the 16 slots ofeach child slot. In some embodiments, the process sorts the paths in theorder of descending number of anchors (i.e., places the paths with themost number of anchors first on its sorted list).

Next, at 6418, the process selects a path according to the sorted order(i.e., selects the paths on the sorted list in a top-to-bottom manner).For the selected path, the process selects (at 6420) one of thepropagation possibilities. In other words, at this stage, the processselects one of the ways that the selected path can propagate between thetwo slots that it is incident upon.

As mentioned above by reference to FIG. 61, some embodiments use apropagation model that provides 10 potential propagations for ahorizontal or vertical path between the current slot's child slots.Also, some embodiments use a propagation model that provides 7 potentialpropagations for a 45° path as shown in FIG. 62, while other embodimentsuse a model that provides 19 potential propagations for a 45° path asshown in FIG. 63.

In some embodiments, the process selects (at 6420) the optimalpropagation for the selected path. To select the optimal propagation,the process examines each propagation possibility, adds virtual pinswhen necessary, costs each propagation possibility, and chooses thepropagation possibility that results in the lowest cost propagation androutes. As described below by reference to FIG. 65, each propagationpossibility might specify one or two propagation paths that traverseinto two or three child slots. Accordingly, the cost of each propagationpossibility includes the cost of the propagation path(s) plus therouting cost of the pin configurations in the two or three child slotsthat the propagation possibility traverses.

FIG. 65 illustrates one example of a propagation possibility of a path.This figure illustrates a net that has actual pins 6525 in slots 0 and9. The selected route for this net uses paths P17 and P24 that traversechild slot 5 to connect child slots 0 and 9. FIG. 65 illustrates thatthe path P24 is propagated along paths 6510 and 6515 into three childslots, (i.e., child slots 0, 1, and 5), while path P17 is propagatedalong path 6520 into two child slots 5 and 9. The propagation path 6510is between the child slot 7 of the current slot's child slot 0 and thechild slot 8 of the current slot's child slot 1. The propagation path6515 is between the child slot 13 of the current slot's child slot 1 andthe child slot 2 of the current slot's child slot 5. The propagationpath 6520 is between the child slot 14 of the current slot's child slot5 and the child slot 2 of the current slot's child slot 9. FIG. 65illustrates five virtual pins 6505 that have been added to the slots ofchild slots 1, 5, and 9.

At 6420, the process also (1) computes the delta cost between the costof the path(s) of the propagation possibility identified at 6420 and thecost of the path selected at 6418, and then (2) increments theTotal_Cost with this delta. For instance, in some embodiments, the deltacost is two when the selected path is a Manhattan path with a cost of 5and the identified propagation is a diagonal path with a cost of 7.Also, in some embodiments, the delta cost is seven when the selectedpath is a diagonal path with a cost of 7, and the identified propagationincludes two diagonal paths, each with a cost of 7. In some embodiments,the delta cost is 0 when the selected path and its identifiedpropagation are both Manhattan paths.

For the propagation selected at 6420, the process, if necessary,temporarily stores (at 6422) virtual pins in the pin configurationrecords of the incident child slots (i.e., the child slots upon whichthe propagation identified at 6430 is incident). The process uses thesetemporarily stored virtual pins in computing the costs of thepropagations of other paths (if any) of the selected route.

The process next determines (at 6424) whether it has examined the lastpath of the selected route. If not, the process returns to 6418 toselect the next path on the sorted path list. It then identifies (at6420) the best propagation for this newly-selected path and temporarilysets (at 6422) any necessary virtual pins.

When the process determines (at 6424) that it has examined all the pathsof the selected route, the process increments (at 6426) the selectedtree's Total_Cost with the cost of the routes in each child slot thathas a pin set for the net. At 6426, the process also stores the selectedroute's Total_Cost. The solving process 5300 uses each tree's Total_Costto formulate its LP problem.

At 6428, the process determines whether it has examined all the routesfor the net selected at 6402. If not, the process transitions to 6404 tocost the next route for this net. When the process determines (at 6428)that it has examined all the routes for the net selected at 6402, theprocess determines (at 6430) whether it has examined all the nets in thecurrent slot. If not, the process transitions back to 6402 to selectanother net in the current slot and to perform the subsequent operationsfor costing the routes for this net. When the process determines (at6430) that it has examined all the nets in the current slot, the costingprocess 6400 ends.

One of ordinary skill will realize that other embodiments compute thewirelength cost of a route differently than the process 6400. Forinstance, the process 6400 computes this cost by computing thewirelength cost at the current recursion level and the one below it.Other embodiments, on the other hand, might compute this cost bycomputing the wirelength cost from the current recursion level all theway down to the leaf-level slots. To do this, some embodiments use arecursive process that computes the path-cost at the current recursionlevel and then recursively call the cost-computing process to computethe wirelength cost for each child slot that is not a Gcell (i.e., foreach child slot that is not a child of a leaf-level slot).

4. LP Problem Formulation and Solver

After the solver assigns wirelength costs to the routes of the nets inthe current slot, the solver formulates (at 5320) an LP problem for theLP solver 3945, which then solves (at 5325) this LP problem. The basicvariables in the LP-problem formulation are the routes for the nets inthe current slot. Each tree is represented in the following format:“xN_C”, where “x” is a character constant, “N” is the net number, “_” isa character constant, and “C” is a number that identifies the tree inthe list of trees for the net. For instance, X26_(—)14 represents the14^(th) tree of net 26.

In some embodiments, each LP solution examined by the LP solver includesa real number value for each tree variable xN_C. The task of the LPsolver is to identify an LP solution that minimizes one or moreobjective functions while satisfying a number of constraints.Specifically, a solution is a viable LP solution only if it satisfiesthe constraint or constraints of the specified LP problem. The LPsolver's task is to identify a viable LP solution (i.e., a solution thatsatisfies the specified constraints) that minimizes the objectivefunction. In other words, from a set of solutions, the LP solveridentifies the viable LP solution that produces the bestobjective-function value.

Some embodiments use as the LP solver 3945 the “SoPlex” solver, whichhas been implemented by Roland Wunderling as a part of a Ph.D. thesisentitled “Paralleler und Objektorientierter Simplex-Algorithmus” (inGerman). Information about this solver is available at the followingwebsite: http://www.zib.de/Optimization/Software/Soplex/.

a. Objective Function

Different embodiments use different objective functions. For instance,some embodiments might use an objective function that (1) minimizestotal length; (2) maximizes minimum slack across all 42 paths; (3)maximizes total slack; and (4) minimizes maximum usage of any individualpath. The embodiments described below, however, try to find an LPsolution that minimizes the following objective function:ObjectiveFunction=A*Total_WireLength+B*Total_Via_Number−C*Min_Slack.  (F)In the equation (F), A, B, and C are weighting factors. Also, theTotal_WireLength is:

$\begin{matrix}{{{Total\_ WireLength} = {\sum\limits_{Tree}{\left( {{Length}\mspace{14mu}{Cost}\mspace{14mu}{of}\mspace{14mu}{the}\mspace{14mu}{Tree}} \right)*\left( {{Variable}\mspace{14mu}{for}\mspace{14mu}{the}\mspace{14mu}{Tree}} \right)}}},} & (G)\end{matrix}$and the Total_Via_Number is:

$\begin{matrix}{{{Total\_ Via}{\_ Number}} = {\sum\limits_{Tree}{\left( {{Number}\mspace{14mu}{of}\mspace{14mu}{Vias}\mspace{14mu}{for}\mspace{14mu}{the}\mspace{14mu}{Tree}} \right)*\left( {{Conversion}\mspace{14mu}{Factor}} \right)*{\left( {{Variable}\mspace{14mu}{for}\mspace{14mu}{the}\mspace{14mu}{Tree}} \right).}}}} & (H)\end{matrix}$

The notion of minimum slack is used in two instances in the LPformulation. First, the variable Min_Slack is used as a component of theobjective function for quantifying the congestion (i.e., serves as anindicia of the congestion in the objective function). Second, theconstant minSlack is used to specify a minimum slack that can betolerated across all 42 paths.

A path's slack is the remaining capacity of a path after accounting forall congestion (i.e., blockages and wireflow) for a particular solution.A negative slack signifies that a path is over congested. Minimizing theobjective function minimizes the negative minimum slack, which, in turn,maximizes the minimum slack. One of ordinary skill will realize thatother embodiments might use other congestion indicia in the objectivefunction.

In some embodiments, the weighting factors A and B for theTotal_WireLength and Total_Via_Number are set equal to each other, andboth these factors are larger than the weighting factor C for theMin_Slack. In other words, these embodiments weight the objectivefunction towards the wirelength and the via count, so that the Min_Slackcomponent makes a difference only when the wirelength and via countcomponents cannot distinguish two LP solutions. These embodiments usethe wirelength and via count components in the objective function toselect solutions that result in smaller total wirelengths and viacounts.

Other embodiments weight the objective function differently. Forinstance, the LP-formulation listed below in subsection VI.E.4.c weightsthe objective function towards the wirelength and the via countparameters only for the first attempt of the LP solver to solve theformulated LP problem. If the LP solver cannot solve the formulatedproblem in its first iteration (i.e., if it cannot find a solution thatmeets the constraints), the LP problem is reformulated so that theMin_Slack component becomes the primary component in the objectivefunction. Specifically, for the first iteration of the LP solver, theformulation below sets the weighting factors A and B for theTotal_WireLength and Total_Via_Number equal to each other, and boththese factors have a larger magnitude than the weighting factor C forthe Min_Slack. If the LP solver does not solve the LP problem in itsfirst iteration, the weighting factors A, B, and/or C are changed sothat the objective function's primary parameter is Min_Slack.

As illustrated by equation (G) above, the Total_WireLength is computedby using the cost of each tree, which was computed at 5315. Also, asillustrated by equation (H) above, the Total_Via_Number is computed byusing the number of vias for each tree. A via is a connection that isneeded to connect two parts of a route that are on two adjacent metallayers.

For the octagonal wiring model illustrated in FIG. 3, a one to onemapping exists between layers and routing directions. This mapping canbe used to easily compute the number of vias for each route. Hence, thenumber of vias can be counted by traversing the route, and identifyingthe number of vias necessary to accommodate (1) the changes in directionof the route and (2) the difference, if any, between the layers of pinsand paths in the child slots.

To account for the layer difference between a pin in a child slot andpath incident upon the child slot, the pin's layer needs to beidentified. Different embodiments identify the layer of an actual pin(i.e., a non-virtual pin) in different ways. For instance, someembodiments assume that all actual pins are on layer 2. Otherembodiments identify the actual layer of a pin; as mentioned above, someembodiments store a pin's layer as part of the pin's location that isstored in the pin data structure 4300, while other embodiments store thepin's layer as part of a pin macro that is stored with the circuit macroreferenced by the slot-data structure. Some embodiments define the layerof a virtual pin (i.e., a pin that is set to account for a propagationof a route into a lower-level child slot) to coincide with the layer ofthe propagated path for which the virtual pin was set.

FIGS. 66 and 67 present two examples that conceptually illustrates onemanner of counting the number of vias. In these examples, the wiringmodel is as follows: layer 2 is vertical, layer 3 is horizontal, layer 4is +45°, and layer 5 is −45°. FIGS. 66 and 67 illustrate two routes forconnecting child slots 0 and 9. In both these figures, child slot 0includes a virtual pin 6605 that was set to account for the propagationof a +45° path into slot 6600. Accordingly, the virtual pin 6605 is saidto be on the fourth metal layer (i.e., the metal layer for the +45°wiring). Also, child slot 9 includes an actual pin, which is on layer 2.

Route 6610 of FIG. 66 needs two vias. This number can be counted bystarting at child slot 0. This slot has one virtual pin in the fourthlayer. Path P24 is incident on this slot, and it traverses the fourthlayer. Hence, no via is necessary to account for the difference betweenthe layers of pin 6605 and path P24. Path P24 is also incident on childslot 5. Child slot 5 has no pin, but it has path P17 incident upon it.As path P24 is on the fourth layer and path P17 is on the second layer,two vias are needed to account for the changes of path direction inchild slot 5. Path P17 is also incident upon child slot 9. Slot 9 has noother paths incident upon it, but it has an actual pin 6615 on layer 2.Given that path P17 and pin 6615 are both on layer 2, no via isnecessary to connect pin 6615 and path P17.

Route 6705 of FIG. 67 needs six vias. This number can be counted bystarting at child slot 0. This slot has one virtual pin in the fourthlayer. Path P12 is incident on this slot, and it traverses the secondlayer. Hence, two vias are necessary to account for the differencebetween the layers of pin 6605 and path P12. Path P12 is also incidenton child slot 4. Child slot 4 has no pin, but it has path P30 incidentupon it. As path P30 is on the fourth layer and path 12 is on the secondlayer, two vias are needed to account for the changes of path directionin child slot 4. Path 30 is also incident upon child slot 9. Slot 9 hasno other paths incident upon it, but it has an actual pin 6615 on layer2. Hence, two vias are necessary to account for the difference betweenthe layers of pin 6615 and path P30. In sum, six vias are necessary forroute 6705. As it can be seen from the examples illustrated in FIGS. 66and 67, the number of vias provides a useful indicia for distinguishingtwo routes that have equal lengths.

Also, some embodiments compute the number of vias for each route duringthe LP formulation 5320. One such embodiment is illustrated by the LPformulation in subsection VI.E.4.c. Other embodiments, however, countthe number of vias for each route before 5320, just as they compute thewirelength cost of a route before 5320 at 5315. Alternatively, someembodiments might compute the wirelength cost of each route during theLP formulation 5320.

FIGS. 68-70 illustrate three processes that work together to compute thenumber of vias in a route. Process 6800 of FIG. 68 starts whenever it iscalled to compute the via count for a tree. This process initiallyinitializes (at 6805) all slots (of the slot currently being solved) asslots that have not been visited.

At 6810, the process 6800 then selects a slot that has only one path ofthe route incident upon it, and defines this slot as the Current_Slot.It then calls (at 6815) process 6900 of FIG. 69 and supplies thisprocess with the Current_Slot. The value returned by process 6900 is thetotal number of vias. After calling process 6900, the process 6800 ends.

The process 6900 is a recursive process. It initially computes (at 6905)the number of vias in the Current_Slot. In some embodiments, the process6900 computes this number by calling the process 7000 of FIG. 70. Theprocess 7000 starts by identifying (at 7005) all the route's paths thatare incident on the Current_Slot. It then identifies (at 7010) all theactual and virtual pins in the Current_Slot.

The process 7000 next identifies (at 7015) the layer of each route pathidentified at 7005 and each pin identified at 7010. Each path's layercan be easily determined as there is a one-to-one mapping between thepath's direction type and its layer, when the octagonal wiring model ofFIG. 3 is used. For instance, some embodiments map vertical paths tolayer 2, horizontal paths to layer 3, +45° paths to layer 4, and −45°paths to layer 5. Also, as described above, some embodiments assume thatall actual pins are on layer 2, while other embodiments identify theactual layer of a pin that is stored. In addition, some embodimentsdefine the layer of a virtual pin (i.e., a pin that is set to accountfor a propagation of a route into a lower-level child slot) to coincidewith the layer of the propagated path for which the virtual pin was set.

After identifying the layers of the pins and the paths, the process 7000then determines (at 7020) the difference between the maximum and minimumlayers identified at 7015. This difference represents an estimate of theminimum number of vias that the route needs in the Current_Slot. If theCurrent_Slot is partitioned into smaller slots, additional vias might beneeded to define lower-level route(s) for the current route's net inand/or between the smaller slots. Some embodiments (1) might perform astatistical study to guess the number of vias needed to define routes inslots with certain number of pins and paths, and then (2) might use theresults of this statistical study to obtain a better estimate of thenumber of vias needed in the Current_Slot. At 7025, the process 7000returns the number of vias in the slot, and then ends.

Once the process 7000 returns the number of vias in the slot, theprocess 6900 marks (at 6910) the Current_Slot as one that has beenvisited. It then selects (at 6915) one of the current route's paths thatare incident on the Current_Slot. Next, at 6920, it identifies the otherslot that the path selected at 6915 is incident upon. At 6925, theprocess determines whether it has examined the slot identified at 6920(i.e., determines whether this slot is marked visited). If not, theprocess 6900 recursively calls itself at 6930. This recursive callspecifies the slot identified at 6920 as the Current_Slot for theprocess that is recursively initiated at 6930. At 6930, the process 6900increments the number of vias by the value that the recursively-calledprocess returns.

From 6930, the process 6900 transitions to 6935. This process alsotransitions to 6935 when it determines (at 6925) that the other slotidentified at 6920 was previously visited. At 6935, the process 6900determines whether there are any other paths incident upon theCurrent_Slot. If so, the process 6900 returns to 6915 to select anotherincident path. If not, the process 6900 returns the computed number ofvias.

As indicated in equation (H) above, the objective function'sTotal_Via_Number not only depends on the number of vias for each tree,but also on a conversion factor that scales the number of vias toreflect their importance relative to the wirelength. This conversionfactor can be obtained by normalizing the wirelength and via costs tothe number of tracks, as indicated in equation (I) below.

$\begin{matrix}{X = {50*{\frac{5}{N}.}}} & (I)\end{matrix}$In this equation, X represents the conversion factor, 5 represents thecost of a Manhattan path, N represents the number of tracks perManhattan path at the current recursion level, and 50 is a penalty costassociated with using a via. This penalty is measured in terms of thenumber of tracks that the router would prefer to detour rather than usea via. In some embodiments, a designer can modify this penalty cost.Also, in some embodiments, each Manhattan path represents 8 tracks atthe Gcell level (i.e., N equals 8 at the Gcell level). Also, conversionfactor X is different for each hierarchical routing level since N isdifferent for each level.

b. Constraints

Different embodiments define different constraints. The embodiments thatuse the LP formulation described below define the three constraints.First, for each net N, the LP solver must only choose 1 tree from theselection set for the net N. This is expressed as a constraint on thesum of the values of the tree variables for the net (i.e., the sum ofthese values must equal 1), as indicated in the equation below:netN: xN _(—) A+xN _(—) B+ . . . xN _(—) Q=1.The LP solver will assign a value between 0 and 1 to each routevariable. A “1” indicates an unambiguous selection of the tree, and a“0” indicates an unambiguous rejection of the tree. A value between 0and 1 means that the solver specified a set of selections that need tobe resolved by the randomized rounding. Some embodiments might notexpress the need to select only one tree for each net as a constraintbut rather as a relationship to generate candidate LP solutions for eachnet.

The second constraints relates to the congestion of the paths in thecurrent slot. In some embodiments, the minSlack has to be greater than aspecified amount. As mentioned above, the minSlack is the smallesttolerable slack across all the paths. The slack in each path equals thecapacity of the path minus wireflow and blockages across the path. Forthe first iteration of the LP solver, some embodiments specify that theminSlack has to be zero or greater. If the LP solver cannot solve theformulated problem in its first iteration, some embodiments reformulatethe LP problem so that the minSlack is a large negative number, in orderto remove the minimum slack as a constraint. However, in someembodiments, this reformulation makes the Min_Slack component of theobjective function the primary component of this function, as describedabove.

Third, the capacity of certain regions needs to be properly shared amongthe paths that can traverse these regions. For instance, given themodels illustrated in FIGS. 61, 62, and 63, diagonal and Manhattan pathsmust properly share the capacity of overlapping diagonal regions. Thisis because when the solver is part of a global router that producesglobal routing results, its global-routing output needs to be convertedinto boundary pin assignments that can be used by a detailed router.

FIGS. 71 and 72 illustrate the need for this sharing constraint at theGcell level. At the Gcell level, some embodiments define the capacity ofthe Manhattan paths crossing between the Gcells to be 8 tracks wide.FIG. 71 shows 8 such tracks across edge E11. Also, some embodimentsassume that the pitch on the diagonal layers is the same as the pitch onthe Manhattan layers and therefore assume that the capacity of adiagonal path is simply square root of two times the capacity of aManhattan path. Under such assumptions, the capacity of a diagonal paththat crosses the above-described Gcells is 11 tracks. FIG. 71illustrates the 11-track-wide capacity of path P32.

Vertically or horizontally adjacent diagonal paths have overlappingrouting regions. For instance, FIG. 72 illustrates two verticallyadjacent diagonal paths P32 and P26 that share the capacity (i.e., thefive diagonal tracks) of shared diagonal region 7205. The five diagonaltracks of diagonal region 7205 are also shared with the Manhattan pathP4 that crosses this region, because, according to the model of FIG. 61,a Manhattan path can traverse between two slots not only in theManhattan direction but also in the diagonal directions.

To account for the shared capacity of the diagonal regions, the LPformulation below defines three sets of constraints, with each sethaving two constraints, one for +45° paths and one for −45° paths. Thesethree set of constraints are: (1) diagonal pair constraints, (2) mixedtriplet constraints, and (3) diagonal triplet constraints. In thediscussion below, +45° paths are referred to as East paths, while −45°paths are referred to as West paths.

FIG. 73 illustrates the first type of constraint, i.e., the diagonalpair constraints. This figure illustrates eight constrained diagonalpairs that have been defined about paths P27 and P36. Two of these are7305, which includes horizontally-adjacent east paths P36 and P38, and7310, which includes vertically-adjacent west paths P27 and P33.

The diagonal pair constraints can be classified as interior or peripheryconstraints depending on whether one of the diagonal paths of the pairis on the periphery of the current slot. Specifically, both pairs 7305and 7310 are interior diagonal pairs. An interior diagonal pair includestwo diagonal paths that are horizontally or vertically adjacent and thatare either from the set of east paths P24, P26, P28, P30, P32, P34, P36,P38, and P40 or from the set of west paths P25, P27, P29, P31, P33, P35,P53, P39, and P41. Three other interior constrained diagonal pairsillustrated in FIG. 73 are (1) pair 7315, which includes paths P36 andP30, (2) pair 7320, which includes paths P27 and P25, and (3) pair 7325,which includes paths P27 and P29.

FIG. 73 also illustrates three constrained periphery diagonal pairs. Aperiphery diagonal pair includes two horizontally- orvertically-adjacent diagonal paths where (1) both are either east pathsor west paths, and (2) one of the paths is one of the interior pathsP24-P41 and the other path is on the periphery edge of the slot. Thethree constrained periphery diagonal pairs illustrated in FIG. 73 are:(1) pair 7330, which includes paths P36 and 7335, (2) pair 7340, whichincludes paths P36 and 7345, and (3) pair 7350, which includes paths P27and 7355.

The two paths in each constrained diagonal pair share several tracks(i.e., several tracks represented by one path are the same as severaltracks represented by the other path). Accordingly, some embodimentsconstrain the congestion about each constrained diagonal pair to accountfor this sharing.

For instance, some embodiments constrain the congestion about aninterior diagonal pairs to be 1.5 times the capacity of either path inthe pair, when the two paths in the pair share about half of the tracks.By way of example, when the two interior diagonal paths P36 and P38 areeach 11 tracks wide and share 5 tracks with each other, some embodimentsspecify a constraint that the congestion about these paths must at mosttake 16 tracks (i.e., specify that wireflow across P36 plus wireflowacross P38 plus any blockages at most take 16 tracks).

Some embodiments also constrain the congestion (i.e., the total wireflowand blockages) about a periphery diagonal pair to be 1.5 times thecapacity of the interior diagonal path, when the two paths in the pairshare about half of the tracks. For example, in some embodiments, thepaths in a periphery diagonal pair 7330 are each 11 tracks wide at theGcell level. At this level, these paths share 5 tracks with each other.Accordingly, for the Gcell level, some embodiments specify a constraintthat the congestion about these path must be 16 tracks or less (i.e.,specify that wireflow across P36 plus wireflow across 7335 plus anyblockages at most take 16 tracks).

Unlike an interior diagonal pair constraint that requires the LP solverto compute the congestion about both the diagonal paths in the pair, aperiphery diagonal pair constraint only requires the LP solver tocompute the congestion about the interior diagonal path of the peripherypair for an LP solution. This is because the congestion about theperiphery path of a periphery diagonal pair is computed during thepropagation operation that preceded the current solve operation.

For instance, the congestion about the periphery path 7335 for theperiphery diagonal pair 7330 might have been computed when the Manhattanor diagonal path incident upon slot 7360 or the diagonal path incidentupon a slot neighboring slot 7360 were propagated down into the childslot 7365 of slot 7360. Some embodiments keep a record of the capacityof a propagated path between a child slot of a first parent slot and thechild slot of a second parent slot that is adjacent to the first parentslot. Some embodiments maintain such a record by (1) creating slot pairrecord for adjacent child slots of adjacent parent slots, (2) storingthe identity of the two adjacent child slots in the slot-pair record,(3) initializing a capacity field that represents the capacity of thepropagated periphery path between the two child slots, and (4)decrementing this capacity for use and blockages. These embodiments thenidentify the capacity of each periphery path by retrieving the slot-pairrecord that stores this capacity. Some embodiments retrieve theslot-pair record by using the identity of the two child slots on whichthe periphery path is incident (i.e., the current slot's child slot, andthe neighboring slot's child slot).

FIG. 74 illustrates the second type of constraint, i.e., the mixedtriplet constraints. This constraint is similar to the first type ofconstraint, the diagonal pair constraint, except that the mixed tripletconstraint constrains the congestion about an adjacent co-lineardiagonal path pair plus the Manhattan path between the diagonal pair.

FIG. 74 illustrates eight constrained mixed triplets, four involvingpath P36 and four involving path P27. Like the diagonal pairconstraints, the mixed triplet constraints can be classified as interioror periphery constraints depending on whether one of the diagonal pathsof the triplet is on the periphery of the current slot.

The four constrained mixed triplets about path P36 in FIG. 74 are: (1)interior mixed triplet 7405, which includes paths P21, P36 and P38, (2)periphery triplet 7410, which includes paths P9, P36 and 7445, (3)periphery triplet 7415, which includes paths P20, P36 and 7455, and (4)interior mixed triplet 7420, which includes paths P6, P36 and P30.

The four constrained mixed triplets about path P27 in FIG. 74 are: (1)interior mixed triplet 7425, which includes paths P14, P27 and P29, (2)interior triplet 7430, which includes paths P4, P27 and 7433, (3)interior triplet 7435, which includes paths P13, P27 and P25, and (4)interior mixed triplet 7440, which includes paths P1, P27 and 7450.

The three paths in each constrained mixed triplet share several tracks.For instance, given the diagonal wire model representation of FIGS. 62and 63, several tracks represented by one of the diagonal paths are thesame as several tracks represented by the other diagonal path. Also,given the Manhattan wire-model representation of FIG. 61, a Manhattanpath can be propagated into lower-level child slots through severaldiagonal paths that compete for the same tracks as the diagonal pathsneighboring the Manhattan path. Accordingly, some embodiments constrainthe congestion about each constrained mixed triplet to account for thissharing.

For instance, when the two diagonal paths in the pair share about halfof the tracks, some embodiments constrain the congestion about aninterior mixed triplet to be 1.5 times the capacity of one of thediagonal path's in triplet plus the capacity of the Manhattan path inthe Manhattan direction only. For example, at the Gcell level, the twointerior diagonal paths P36 and P38 are each 11 tracks wide and share 5tracks with each other, while the Manhattan path P21 is 8-tracks wide inthe Manhattan direction and 5-tracks wide in the East direction (i.e.,path P21 can use 8 tracks on the vertical layer of wiring and 5 tracksin the East layer wiring). Accordingly, at the Gcell level, some ofthese embodiments specify a triplet constraint that the congestion(i.e., wireflow plus blockages) about paths P21, P36, and P38 must atmost take 24 tracks (i.e., the 16 available East tracks plus the 8available vertical tracks).

Other embodiments might constrain the congestion an interior mixedtriplet to be 1.5 times the capacity of one of the diagonal path's intriplet plus the capacity of the Manhattan path in the Manhattandirection and the opposite diagonal direction, when the two diagonalpaths in the pair share about half of the tracks. So, for the aboveexample (where, at the leaf-slot level, the two interior diagonal pathsP36 and P38 are each 11 tracks wide and share 5 tracks with each other,while the Manhattan path P21 is 8-tracks wide in the Manhattandirection, 5-tracks wide in the East direction, and 5-tracks wide on theWest direction), some of these embodiments specify a triplet constraintthat the congestion about paths P21, P36, and P38 must at most take 29tracks (i.e., the 16 available East tracks plus the 8 available verticaltracks plus 5 available West tracks).

In addition, like the periphery diagonal pair constraints, the peripherymixed triplet constraints are analyzed like the interior constraints insome embodiments, except for the computation of the congestion about theperiphery path of the triplet during the prior propagation operation. Inother words, an interior mixed triplet constraint requires the LP solverto compute the congestion about both the triplets diagonal paths andManhattan path for an LP solution. The periphery mixed tripletconstraint only requires the LP solver to compute the congestion aboutthe triplet's interior diagonal path and the Manhattan path for an LPsolution. The LP solver can retrieve the congestion about the peripherypath from the slot-pair record for the two child slots that theperiphery path traverses.

FIG. 75 illustrates the third type of constraint, i.e., the diagonaltriplet constraints. This constraint is similar to the first type ofconstraint, the diagonal pair constraint, except that the diagonaltriplet constraint constrains the congestion about three co-lineardiagonal paths instead of two. FIG. 75 illustrates four constraineddiagonal triplets, two involving path P36 and two involving path P27.Like the diagonal pair constraints, the diagonal triplet constraints canbe classified as interior or periphery constraints depending on whetherone of the diagonal paths of the triplet is on the periphery of thecurrent slot. The four constrained diagonal triplets in FIG. 75 are: (1)periphery diagonal triplet 7505, which includes paths P36, P38 and 7530,(2) periphery diagonal triplet 7510, which includes paths P30, P36 and7525, (3) interior diagonal triplet 7515, which includes paths P25, P27and P29, and (4) periphery diagonal triplet 7520, which includes pathsP27, P33, and 7535.

Given the diagonal wire model representation of FIGS. 62 and 63, themiddle path in the triplet shares several tracks with the other twodiagonal paths. Accordingly, some embodiments constrain the congestionabout each constrained diagonal triplet to account for this sharing.

When the middle diagonal path in the triplet shares about half of itstracks with one of the other diagonal paths and shares the other halfwith the other diagonal path, some embodiments constrain the congestionabout a diagonal triplet to be 2.0 times the capacity of one of thediagonal path's in triplet. For example, in some embodiments at theGcell level, each diagonal path is 11 tracks wide, and shares 5 trackswith each neighboring co-linear diagonal path. Accordingly, for theGcell level, some embodiments specify a triplet constraint that thecongestion (i.e., wireflow plus blockages) about the three diagonalpaths in a triplet (e.g., about paths P25, P27, and P29) must at mosttake 22 tracks.

In addition, like the periphery diagonal pair and mixed tripletconstraints, the periphery diagonal triplet constraints are analyzedlike the interior constraints in some embodiments, except for thecomputation of the congestion about the periphery path of the tripletduring the prior propagation operation. Specifically, an interiordiagonal triplet constraint requires the LP solver to compute thecongestion about all the diagonal paths of the triplet. On the otherhand, a periphery diagonal triplet constraint only requires the LPsolver to compute the congestion about the triplet's interior diagonalpaths. The LP solver can retrieve the congestion about the peripherydiagonal path from the slot-pair record for the two child slots that theperiphery path traverses.

One of ordinary skill will realize that other embodiments might defineother constraints. For instance, some embodiments might define a mixedquintuplet constraint, which constrains the congestion about a Manhattanpath and the two pairs of adjacent co-linear diagonal paths. One suchquintuplet would include vertical path P13, −45° diagonal paths P25 andP27, and +45° diagonal paths P24 and P26.

The Manhattan path in each quintuplet would share several tracks withthe quintuplet's diagonal paths. In addition, the paths in each paralleldiagonal pair share several tracks. Accordingly, when the two diagonalpaths in each pair share about half of the tracks, some embodimentsconstrain the congestion about a mixed quintuplet to be about 3.0 timesthe capacity of one of the diagonal path's in quintuplet plus thecapacity of the Manhattan path in the Manhattan direction only. Forexample, in some embodiments at the leaf-slot level, each diagonal pathis 11 tracks wide and shares 5 tracks with its adjacent co-lineardiagonal path, while each Manhattan path is 8-tracks wide in theManhattan direction. Accordingly, at the Gcell level, some of theseembodiments specify a quintuplet constraint that the congestion aboutthe quintuplet must at most take 40 or 41 tracks, depending on whetherthe capacity about each parallel diagonal pair is truncated or not.

c. Formulation

In some embodiment, the solver 3930 formulates the LP problem based onthe above-described objective function and constraints. The formulationof the LP problem in some of these embodiments is as follows:

[prepSolverILP(slot)]

-   initialize variable minSlack to 0 // paths are not allowed to be    over-constrained-   initialize variable lenAndViaWeight to 100 // initially length and    via count has priority over minimizing slack-   initialize variable minSlackWeight to —1-   while (! done)    -   declare & initialize the LP solver    -   declare objective row, and name it “objective”    -   for each identified set of trees for a net in the variable that        stores all sets of identified trees for all nets in the current        slot        -   if set is not empty (i.e., the set contains tree selection            set for a net in this slot)            -   retrieve net index, N, from first tree record in set            -   declare a constraint, “rN”, to constrain the solver to                choose only 1 tree for this net    -   for each path, N, in the slot        -   declare a constraint, “usageN”, to define a variable summing            the total usage of this path        -   declare a constraint, “eSlackN”, to define a maximum slack            value over all paths        -   declare a constraint, “mxuseN”, to define a maximum usage            value over all paths        -   if path N is a Manhattan path            -   declare a constraint, eMtplN, to constrain the sum of                usages of Manhattan path N, and adjacent pair “east”                paths // this constraint is for the mixed triplet that                includes path N and 2 diagonal east paths adjacent to it            -   declare a constraint, wMtplN, to constrain the sum of                usages of Manhattan path N, and adjacent “west” paths //                this constraint is for mixed triplet that includes path                N and 2 diagonal west paths adjacent to it            -   declare a constraint, epairN, to constrain the sum of                usages of the 2 “east” paths adjacent to path N // this                constraint is for diagonal pair that includes 2 diagonal                east paths adjacent to path N            -   declare a constraint, wpairN, to constrain the sum of                usages of the 2 “west” paths adjacent to path N // this                constraint is for diagonal pair that includes 2 diagonal                west paths adjacent to path N            -   declare a constraint, eDtplN, to constrain the sum of                usages of the 2 “east” paths adjacent to path N, plus a                3rd east path below or to the left of the                bottom-most/left-most adjacent east path // this                constraint is for diagonal triplet that includes 2                diagonal east paths adjacent to path N plus a 3rd east                path below or to the left of the bottom-most/left-most                adjacent east path            -   declare a constraint, wDtplN, to constrain the sum of                usages of the 2 “west” paths adjacent to path N, plus a                3rd west path below or to the left of the                bottom-most/left-most adjacent west path // this                constraint is for diagonal triplet constraints that                includes 2 diagonal west paths adjacent to path N plus a                3rd west path below or to the left of the                bottom-most/left-most adjacent west path        -   define a constraint, “Min_Slack”, to limit the value of the            minimum slack across all paths        -   define a constraint, “tLen”, to define a variable summing            the length costs of all chosen trees        -   define a constraint, “tVias”, to define a variable summing            the via costs of all paths-   // at this point, all the “rows” of the LP are declared. Now we    continue by filling in the columns (i.e. declaring the variables)    -   for each set of trees, treeset, for a net in the variable,        m_sols, that stores the sets of trees for all nets in the        current slot        -   identify the net to which this set of trees belongs        -   for each tree in treeset            -   create a variable, “xN_T”, where N is the net index and                T is the ordinal number of the tree, to represent this                tree            -   declare xN_T to be present with factor 1.0 in constraint                “rowN”            -   identify wirelength cost of tree xN_T // computed by                process 6400 described above            -   compute the number of vias, “nVias”, required to embed                this tree // uses the processes 6800-7000 described                above            -   declare xN_T to be present with factor estLen in                constraint “tLen”            -   declare xN_T to be present with factor nVias times X in                constraint “tVias” // where X is the conversion factor                that was described above by reference to equation (I)            -   for each path, E, in the slot                -   if this tree uses path E                -    declare xN⁻T to be present with factor −1.0 in                    constraint usageE    -   for each path, E, in this slot        -   create variable, “uE”, where E is an integer identifier of            the path        -   declare uE to be present with factor 1.0 in constraint            “usagee”        -   declare u to be present with factor −1.0 in constraint            “mxuseE”        -   declare uE to be present with factor 1.0 in constraint            “eslackE”        -   if path E is a Manhattan path            -   declare uE to be present with factor 1.0 in constraint                “eMtplE”            -   declare uE to be present with factor 1.0 in constraint                “wMtplE”            -   retrieve two pairs of diagonal paths adjacent to path E            -   for each path, A, in the pairs                -   if the direction of path A is “east”                -    declare uA to be present with factor 1.0 in                    constraint eMtplE                -    declare uA to be present with factor 1.0 in                    constraint epairE                -   if the direction of path A is “west”                -    declare uA to be present with factor 1.0 in                    constraint wMtplE                -    declare uA to be present with factor 1.0 in                    constraint wpairE            -   retrieve triple of diagonal paths adjacent to path E            -   for each path, B, in the triple                -   if the direction of path B is “east”                -    declare uB to be present with factor 1.0 in                    constraint eDtplE                -   if the direction of path B is “west”                -    declare uB to be present with factor 1.0 in                    constraint wDtplE    -   create variable, “slack”    -   declare slack to be present with factor 1.0 in constraint        “Min_Slack”    -   declare slack to be present with factor “minSlackWeight” in the        objective function    -   for each path, E, in this slot        -   declare slack to be present in constraint with factor 1.0 in            constraint “eslackE”        -   if path E is a manhattan path            -   declare slack to be present with factor 1.0 in                constraint “epairE”            -   declare slack to be present with factor 1.0 in                constraint “wpairE”            -   declare slack to be present with factor 1.0 in                constraint “eMtplE”            -   declare slack to be present with factor 1.0 in                constraint “wMtplE”            -   declare slack to be present with factor 1.0 in                constraint “eDtplE”            -   declare slack to be present with factor 1.0 in                constraint “wDtplE”    -   create variable, “tV”    -   declare tV to be present with factor 1.0 in constraint “tVias”    -   declare tc to be present with factor “lenAndViaWeight” in the        objective function    -   create variable “tL”    -   declare tl to be present with factor 1.0 in constraint “tLen”    -   declare tl to be present with factor “lenAndViaWeight” in the        objective function-   // up to here, we have declared constraints and filled in the left    hand sides of their equations. Now, we'll set their right hand sides    -   for each set of trees, treeset, for a net in the variable,        m_sols, that stores the sets of trees for all nets in the        current slot        -   if set is not empty (set contains tree selection set for a            net in this slot)            -   retrieve net index, N, from first tree record in set            -   set RHS of constraint, “rN”, to equal to 1.0    -   for each path, E, in this slot        -   set the rhs of constraint “usageE” equal to 0.0        -   set the rhs of constraint “mxuseE” equal to 0.0        -   retrieve capacity estimate, cap(E), produced by subtracting            estimated path use (computed by process 5500) from estimate            unblocked value (computed by process 5400)        -   set the rhs of constraint “eslacke” to cap(E)        -   if path E is a Manhattan path            -   calculate capacity estimate for sharing constraint                eMtplE, capeMtplE, and set the rhs of constraint eMtplE                to this capacity            -   calculate capacity estimate for sharing constraint                wMtplE, capwMtplE, and set the rhs of constraint wMtplE                to this capacity            -   calculate capacity estimate for sharing constraint                epairE, capepairE, and set the rhs of constraint epairE                to this capacity            -   calculate capacity estimate for sharing constraint                wpairE, capwpairE, and set the rhs of constraint wpairE                to this capacity            -   calculate capacity estimate for sharing constraint                eDtplE, capeDtplE, and set the rhs of constraint eDtplE                to this capacity            -   calculate capacity estimate for sharing constraint                wDtplE, capwDtplE, and set the rhs of constraint wDtplE                to this capacity    -   set the rhs of constraint “tVias” equal to 0.0    -   set the rhs of constraint “tLen” equal to 0.0    -   set the rhs of constraint “Min_Slack” equal to variable minSlack    -   solve the LP    -   if no solution exists // remove hard constraint on minimum        slack, reset weights such that slack is priority over length and        via count        -   set variable minSlackWeight=−500        -   set variable minSlack=−1000        -   set variable lenAndViaWeight=1    -   if solution was found        -   exit while loop

As indicated above, the third-to-last statement of the formulation tells(at 5325) the LP solver to solve the problem. The LP solver then triesto solve this problem. If the LP solver fails to solve this problem inthe first iteration through the while loop described above, theformulation above changes values of certain constants so that theminimum slack is no longer much of a constraint but rather serves as theprimary component of the objective function. Specifically, the change tothe constants minSlackWeight, minSlack, and lenAndViaWeight effectivelymakes the capacity constraint (which is the only constraint that wouldcause the first attempt to fail) ineffective. The LP solver then triesto solve the problem again. The change to the constants minSlackWeight,minSlack, and lenAndViaWeight ensures that the second attempt willproduce a solution. One of ordinary skill will understand that otherembodiments might change the value of these variables more incrementallyto find solutions with different characteristics. However, suchincremental changes might reduce the speed of the solver.

The solution that the LP solver returns is one that meets all theconstraints and produces the lowest objective-function output. Thereturned solution may include real numbers for each tree variable xN_C.For instance, if the solver submitted three routes to the LP solver, theLP solver might return a score of 0.8 for one route, 0.1 for the otherroute, and 0.1 for the last route.

As mentioned above, the process 5300 converts (at 5330) this LP solutioninto an ILP solution, i.e., a solution that specifies a 0 or 1 as thevalue of each tree variable xN_C. Also, as mentioned above, someembodiments use randomized rounding to perform this conversion. Based onthe set of routes selected at 5330, the solver 3930 stores (at 5335) a42-bit selected route string in each slot-net data structure of thecurrent slot. This 42-bit string specifies the paths in the current slotthat the selected route of the net takes.

One of ordinary skill will understand that despite the above descriptionof the solver, other embodiments might use different approaches to solvethe routing problem at any particular level of the routing hierarchy.For instance, some embodiments might define objective functions andconstraints in a different manner than those described above. Forinstance, some embodiments might use the cost of a route as aconstraint, and have the objective function simply minimize congestion.Also, instead of using an LP solver to generate an LP solution andconverting the LP solution into an ILP solution, other embodiments usean ILP solver to generate an ILP solution. Yet other embodiments use asequential approach to embed routes for each net in the current slot.

F. Propagator

After the solver specifies the route for each slot-net of the currentslot, the slot manager 3925 calls the propagator 3935 when the currentslot is not at a leaf slot. The propagator then determines how therouting paths specified by the solver for the current routing levelpropagate down into the child slots of the current slot. For slots thatare after the top-level slot but before the leaf-level slot, thepropagator also performs a follow-up propagation operation thatpropagates the paths specified by the propagator at the previous routinglevel one level further down. For each net in the current slot, thepropagator might have to modify the net's pin distribution within eachchild slot to account for the propagations that it identifies.

Two different propagators are described below. The first propagatorenumerates several propagation solutions for each net's route and thenuses the LP solver 3945 and ILP converter 3950 to select a propagationsolution for each net. The second propagator, on the other hand, is asequential propagator that uses a greedy approach to select and embed apropagation for the route of each net in the current slot. In theembodiments described below, both these propagators also use asequential propagator to perform the follow-up propagation, whenapplicable.

Some embodiments use the first propagator when they use theseven-permutation propagation model of FIG. 62 for diagonal paths, anduse the second propagator when they use the nineteen-permutationpropagation model of FIG. 63 for diagonal paths.

Some of these embodiments use the ten-permutation propagation model ofFIG. 61 for Manhattan paths, in conjunction with either of these models.

1. ILP Propagator

Like the solver, the ILP propagator enumerates and costs severalpropagation solutions for each net's route into the affected childslots. The propagator then formulates an LP problem and feeds thesesolutions to the LP solver 3945, which, in turn, returns a number ofreal-number solutions. These real-number solutions are then convertedinto integer solutions by the ILP solver 3950. These integer solutionsspecify a particular configuration for each net within each affectedchild slot, and the propagator stores each net's configuration in thenet's slot-net data structure for the affected child slot.

FIG. 76 illustrates a process 7600 that the ILP propagator performs insome embodiments. In some embodiments, this process starts when the slotmanager calls the propagator and supplies it with a current slot. Theprocess 7600 initially estimates (at 7605) the availability of eachpropagation possibility of each path. One manner of estimating theavailability of the propagations will be described below by reference toFIGS. 77 and 78.

After estimating the availability of each propagation possibility ofeach path, the process 7600 enumerates and costs (at 7610) allpropagation permutations for each slot-net in the current slot. Onemanner of enumerating and costing the propagations will be describedbelow by reference to FIGS. 79 and 80.

After enumerating and costing the potential propagation permutations,the LP propagator formulates an LP problem for the LP solver 3945. Onemanner of formulating the LP propagation problem will be described belowin Section VI.F.1.d. The process 7600 then converts (at 7625) the LPsolution returned by the LP solver to an ILP solution. In someembodiments, the process performs randomized rounding to make thisconversion. One manner of performing randomized rounding was describedabove in Section VI.E.

Based on the propagations specified at 7625, the process then modifies(at 7630) the 16-bit pin distributions of the slot-nets in the childslots of the current slot, when necessary. If at this stage there is noslot-net data structure to modify for a particular net, the propagatorwill instantiate one and record the 16-bit pin distribution in it.

When the current slot's level is at least two levels above the leaflevel, the process 7600 adds (at 7635) the propagation paths that itidentified at 7625 to the follow-up propagation list for the next lowerrecursion level. When the current slot's level is after the top levelbut before the leaf level, the propagator then performs (at 7640) afollow-up propagation operation. This operation propagates the routingpaths specified by the propagator at the previous routing level onelevel further down. One manner of performing follow-up propagation isexplained below by reference to FIGS. 65 and 81.

When the current slot's level is the level immediately before the leaflevel (i.e., when the current slot is a grandparent of Gcells), theprocess 7600 next calls (at 7645) the saver to link to the dBNets 4110the path data structures of the propagation paths specified at 7625 and,when applicable, for the propagation paths specified at 7640. Theprocess then ends.

a. Estimating Congestion of the Propagations.

As mentioned above, the process 7600 estimates (at 7605) the remainingavailability of each propagation possibility for each path in thecurrent slot. In some embodiments, the process 7600 computes thisestimate by (1) estimating the blocked capacity of each propagation ofeach path, (2) estimating the use of each propagation of each path, and(3) summing each propagation's blocked capacity and use. The estimationof the blocked capacity of each propagation is described below byreference to FIG. 77, while the estimation of the use of eachpropagation is described below by reference to FIG. 78.

(1) Estimated Blocked Capacity of Each Path.

FIG. 77 illustrates a process 7700 for estimating the blocked capacityof each propagation of each path in the current slot. The propagationprocess 7600 performs process 7700 at 7605. Initially, this processallocates (at 7702) a data structure (e.g., a matrix) that has at leastone field for storing the blocked capacity of each propagation of eachpath in the current slot. At 7702, the process also initializes eachfield in the data structure to 0.

At 7704, the process selects a circuit module in the current slot's listof circuit modules. The process then retrieves (at 7706) the circuitmacro for the selected circuit module. It then selects (at 7708) anobstacle on the circuit macro, and computes (at 7710) the bounding boxof the selected obstacle.

Next, the process (at 7712) selects one of the 42 paths of the currentslot. It then selects (at 7714) one of the propagations of the pathselected at 7712. The process next determines (at 7716) whether pathselected at 7712 is on the same layer as the obstacle selected at 7708.

If the selected path's layer matches the selected obstacle's layer, theprocess calculates (at 7726) the bounding box of the selectedpropagation. At 7726, the process also calculates the area of thebounding box of the propagation. The process next identifies (at 7728)the intersection of the selected propagation's bounding box and theselected circuit module's bounding box, and calculates (at 7730) thearea of this intersection. The process computes (at 7732) an obstructionfactor by dividing they calculated intersection area by they calculatedpropagation area. The process next multiplies (at 7734) the obstructionfactor by the default propagation capacity, and then adds (at 7736) theresult of this multiplication to the propagation's blocked capacity thatis stored in the data structure allocated at 7702. The process thentransitions to 7718, which is described below.

If the process determined at 7716 that the selected path's layer is notthe same as the selected obstacle's layer, the process transitions to7718. At 7718, the process determines whether it has examined all thepropagations for the path selected at 7712. If not, the process returnsto 7714 to select another propagation for the selected path. On theother hand, if the process determines (at 7718) that it has examined allthe propagations for the path selected at 7712, the process determines(at 7720) whether it has examined all the paths of the current slot. Ifnot, the process returns to 7712 to select another path of the currentslot.

Alternatively, if the selected path is the last path of the currentslot, the process determines (at 7722) whether it has examined all theobstacles of the circuit module selected at 7704. If not, the processtransitions to 7708 to select another obstacle of the selected circuitmodule. Otherwise, the process determines (at 7724) whether it hasexamined all the circuit modules in the current slot. If not, theprocess transitions to 7704 to select another circuit module in thecurrent slot. However, if the process examined all the circuit modulesin the current slot, the process ends.

b. Estimated Use of Each Path Propagation.

FIG. 78 illustrates a process 7800 for estimating the use of eachpropagation of each path in the current slot. This process starts eachtime the propagator calls it at 7605. In some embodiments, the process7800 receives from the propagator a data structure (e.g., a matrix) offloating-point variables for storing the estimated use of eachpropagation. In other embodiments, the process 7800 does not receivesuch a data structure, but rather creates this structure when it starts.In some embodiments, the received or created data structure has at leastone entry for each propagation possibility.

As shown in FIG. 78, the process 7800 initially selects (at 7805) one ofthe child slots of the current slot. It then calls (at 7810) thepath-use estimating process 5500 of FIG. 55 for the selected child slot.The path-use estimating process 5500 computes and returns an estimatedusage value for each path of the selected child slot. As the estimatingprocess 5500 was described above, it will not be described here in orderto not obscure the description of the invention with unnecessary detail.

After 7810, the process 7800 determines (at 7815) whether it hascomputed the path usage values for all the child slots of the currentslot. If it has not, it returns to 7805 to select another child slot,and computes (at 7810) the path-usage values for the newly-selectedchild slot. When the process determines (at 7815) that it has examinedall the current slot's child slots, it selects (at 7820) one of the 42paths in the current slot.

At 7825, the process selects one of the propagations for the selectedpath. It then computes (at 7830) an estimate of the use of the selectedpath propagation based on that path-usage values of the neighboringchild slot paths. For instance, in some embodiments of the invention,the process uses the formula below to compute the usage of propagate 0of path 1:prop_(—)0-path_(—)1_use=(½)*(½*path[1][2]+⅓*path[1][1]+⅙*path[1][0]+½*path[2][0]+⅓*path[2][1]+⅙*path[2][2]),where path[i][j] refers to the usage of path j of child slot i. Similarequations can be used to analogously define the propagation usage valuesfor the other propagation possibilities.

The equation above defines a propagation usage value for propagation 0of path 1 between child slots 1 and 2 in terms of the congestion withinchild slots 1 and 2. This equation only examines the horizontal path inthe child slots that are in line with propagation 0 of path 1.Specifically, it examines the component usage value of propagate 0 ofpath 1 in terms of the horizontal paths 0, 1, and 2 of child slots 1 and2. The summation of the usage values in both child slots 1 and 2 ismultiplied by ½ to reflect that the capacity of propagation 0 of path 1in the current slot is equally influenced by the capacities of the childpaths in child slots 1 and 2.

The multipliers ½'s, ⅓'s and ⅙'s are used in the summation for bothchild slots 1 and 2 for the following reasons. The objective is to guesshow many wires can be pushed through a propagate path. Some of thesewires will terminate immediately after crossing the propagate path,while some will cross the entire width of the slot incident to the path.It is assumed that there will be a uniform distribution of “endpoints”of the wires using the path, such that for propagate 0 of path 1 ¼ willterminate in slot 0 of child slot 2, ¼ will terminate in slot 1 of childslot 2, ¼ in slot 2 of child slot 2 and ¼ in slot 3 of child slot 2 andbeyond. This means that ¾ of the wires that use the path 1 will also usepath 0 of child slot 2, 2/4 will use path 1 in child slot 2, and ¼ willuse path 3 in child slot 2—which gives a ratio of 3:2:1 (or 3/6, 2/6, ⅙)of relative impact of the usages of these 3 paths on the estimated useof the propagated path.

At 7835, the process determines whether it has examined all thepotential propagations of the path selected at 7820. If not, the processtransitions back to 7825 to select another propagation for the selectedpath, and computes (at 7830) an estimate of the use of thenewly-selected propagation.

When the process determines (at 7835) that it has examined all thepropagations for the path selected at 7820, the process determines (at7840) whether it has examined all the paths of the current slot. If ithas not examined all paths, the process transitions back to 7820 toselect another path of the current slot, and then performs operations7825-7835 to compute the use of the propagation possibilities of thenewly-selected path. When the process determines (at 7840) that it hasexamined all the paths in the current slot, the process ends.

c. Enumerating and Assigning Costs for Each Propagation

After estimating the availability of each propagation possibility ofeach path, the process 7600 enumerates and costs (at 7610) allpropagation permutations for each slot-net in the current slot. FIG. 79illustrates one manner of enumerating and costing the propagations.

As shown in FIG. 79, the process 7900 starts by selecting (at 7905) aslot-net of the current slot. The process then initializes (at 7910) 16empty lists, one for storing the paths incident on a particular childslot. The process next retrieves (at 7915) the route for the slot-netselected at 7905.

At 7920, the process selects one of the paths of the retrieved route. Itthen identifies the two child slots corresponding to the end points ofthe selected path. The process adds the selected path to the path listof each child slot identified at 7925. At 7935, the process determineswhether it has examined all the paths of the route retrieved at 7915. Ifnot, the process returns to 7920 to select another path of the route.

When the process determines that it has added all the paths of the routeto their corresponding child slots' lists, the process selects (at 7940)one of the child slots of the current slot and retrieves the list ofpaths of the selected child slot. The process selects the child slot at7940 in order to enumerate and cost all the possible propagationpermutations of the selected slot-net in the selected child slot. At7945, the process retrieves the selected slot-net's pin distribution inthe selected child slot.

At 7950, the process initializes an empty list to store all possiblepath propagation configurations in the child slot selected at 7940. At7955, the process determines whether the selected child slot's path listis empty (i.e., whether the slot-net's route has any paths that traversethe child slot). When the slot-net's route does not traverse theselected child slot, the process does not need to identify propagationconfigurations for the slot-net's route through the selected child slot.Accordingly, the process transitions to 7985 to determine whether it hasexamined all the child slots of the current slot. The flow of theprocess 7900 from 7985 will be described below.

If the process determines (at 7955) that the slot-net's route traversesthe selected child slot and that it therefore needs to identifypropagation configurations for the slot-net's route in the selectedchild slot, the process 7900 performs 7960-7980 to enumerate, cost, andstore all the possible propagation permutations of the selected slot-netin the selected child slot.

In some embodiments, the process 7900 uses a recursive function toperform 7955-7980. This function identifies each path-propagationpermutation by (1) selecting one possible propagation for a path on theselected child slot's path list, (2) setting a virtual pin to accountfor the selected propagation, (3) recursively repeating the first twooperations for each of the subsequent paths on the path list when suchpaths exist. For each identified propagation permutation, the process7900 then performs 7970-7975 to cost and save each permutation, and addeach permutation to a list of propagation configurations.

More specifically, at 7960, the process 7900 identifies one permutationof path propagations in the selected child slot. When the slot-net'sroute has only one path that is incident on the selected child slot, theidentified propagation permutation is one of the propagationpossibilities for the path incident on the selected child slot. On theother hand, when the slot-net's route has more than one path incident onthe selected child slot, each identified permutation is a uniquecombination of propagations for each of the paths incident on theselected child slot.

As illustrated in FIG. 61, a horizontal vertical path has tenpropagation possibilities in some embodiment of the invention. On theother hand, a diagonal path has seven propagation possibilities in someembodiment as illustrated in FIG. 62, while it has nineteen propagationpossibilities in other embodiments as illustrated in FIG. 63. One ofordinary skill will understand that other embodiments use otherpropagation models for horizontal, vertical, or diagonal paths.

After identifying one permutation of path propagations in the selectedchild slot, the process identifies (at 7965) a pin configuration thataccounts for the path propagations of the permutation identified at7960. Such a pin configuration is the same as the slot-net's pindistribution in the selected child slot except that it might include oneor more virtual pins to account for path propagations of the identifiedpermutation.

The process then computes (at 7970) the cost of the pin configurationidentified at 7965. In some embodiments, this cost is the wirelengthcost of the route necessary for connecting the selected child slot'spins that are specified by the identified pin configuration. As before,some embodiments retrieve this cost from a pre-tabulated table thatspecifies the cost of the optimal Steiner routes for each pinconfiguration, while other embodiments compute this cost in real timebased on the costs of the route paths.

At 7970, the process stores the identified propagation permutation(i.e., the identified path propagations) and its cost in a configurationrecord. The data structure for such a record is illustrated in FIG. 80.The propagator creates a list of this data structure and uses this listto keep track of all the configurations generated by the propagator.This data structure includes a reference to the net's dbNet datastructure. It also contains a child-slot identifier that identifies forthe propagator the identity of the child slot for the configuration.This structure also includes a name from which path propagations can bederived. It further stores the wirelength cost and a list of paths.

After 7970, the process adds (at 7975) the configuration record createdat 7970 to a list of configuration for the selected child slot. Theprocess then determines (at 7980) whether it has examined all thepath-propagation permutations in the selected child slot. As mentionedabove, some embodiments perform this determination as part of arecursive function that identifies all the path-propagationpermutations.

If the process determines (at 7980) that it has not examined allpath-propagation permutations, it identifies (at 7960) anotherpermutation and then costs and stores (at 7965-7975) this permutation.When the process has examined all path-propagation permutation, itdetermines (at 7985) whether it has examined all the child slots. Ifnot, the process returns to 7940 to select another child slot.

When the process determines (at 7985) that it has examined all the childslots, the process determines (at 7990) whether it has generated thepropagation permutations for all slot-nets in the current slot. If not,the process returns to 7905 to select another slot-net, and thenperforms subsequent operations to enumerate and cost the propagationpermutations for the newly-selected slot-net. The process ends when ithas examined all the slot-nets in the current slot.

d. LP Problem Formulation and Solving

The ILP propagator 3935 formulates the LP problem by providing the LPsolver 3945 with one or more objective functions, a number of solutions,and several constraints. The LP solver then needs to use the objectivefunctions to select the optimal solution in view of constraints.

The basic variables in the LP-propagation formulation are theconfiguration records, nXtYeApB . . . , where the lower case letters arekeywords (n=net; t=child slot; e=path; p=propagation), and theupper-case letters represent numbers (from 0 to the number of nets inthe design for ‘n’; from 0-15 for ‘t’; from 0-41 for ‘e’; and from 0-9for ‘p’).

This LP solver returns an LP solution that includes a real number valuefor each configuration variable. As mentioned above, the process 7600then converts this LP solution into an ILP solution, i.e., a solutionthat specifies a 0 or 1 as the value of each configuration variable.Instead of using an LP solver to generate an LP solution and convertingthe LP solution into an ILP solution, other embodiments use an ILPsolver to generate an ILP solution.

As mentioned above, some embodiments use as the LP solver the “SoPlex”solver, which has been implemented by Roland Wunderling as a part of hisPh.D. thesis entitled “Paralleler und ObjektorientierterSimplex-Algorithmus” (in German). Information about this solver isavailable at the following website:

http://www.zib.de/Optimization/Software/Soplex/.

Also, as mentioned above, the task of the LP solver is to identify an LPsolution that minimizes one or more objective functions while satisfyinga number of constraints. The embodiments described below specify thefollowing objective function for the LP propagation.minimize: L1nXtYeApB+ . . . +LLnQtWeDpCeApD+ . . .This objective function minimizes the total length. Specifically, eachterm in this function represents a configuration (i.e., a completeselection of propagations of paths for a net in a child slot), and ismultiplied by the estimated length of that configuration (L1, LL).

Also, the embodiments described below specify three constraints. Thefirst constraint requires the LP solver to pick only one configurationfor every slot-net, as indicated below.nXtY: nXtYeApB..eQpZ+nxtYeApC.eQpR+. . . =1;One such constraint is defined for each slot-net across the 16child-slots of the most recently solved slot. This constraint serves tolimit number of selected configurations to 1 per slot-net.

The second constraint is a propagation consistency constraint, whichserves to ensure coherency between child slots (e.g., if propagation Bis chosen for path A in child slot Y, then the same choice must be madein the other child slot incident to path A). This constraint can bespecified as follows:nXeYpZ: nXt0eYpZeQp1+nXt0eYpZeQp2+nXt0eYpZeQp7 . . .−nXt1eYpZeSp1−nXt1eYpZeSp2−nXt1eYpZeSp3=0Note that there will be as many positive terms as there areconfigurations specifying propagation B for path A in child slot Y fornet X, and there will be as many negative terms as there areconfigurations specifying propagation B for path A in child slot W fornet X.

The third constraint is a capacity constraint. Some embodiments map theslot-net configurations in the child slots to usage of paths between thegrandchild slots (i.e., map each propagation in the child slots to useof paths between the grandchild slots). These embodiments then ensurethat the capacity of the paths between grandchild slot are respected.

The formulation of the LP-propagation problem in some of theseembodiments is as follows:

[prepPropagationILP(slot)]

-   initialize slack=0-   while we don't have a solution    -   initialize a new LP solver    -   declare the objective function, “objective”    -   for each path of the slot        -   for each propagation of the path            -   retrieve all paths comprising the propagation            -   for each path of the propagation                -   retrieve the (child-slot, grandchild-slot) pairs                    that serve as endpoints of the path (a child-slot,                    grandchild-slot pair may occur in more than one                    propagation)                -   if this (child-slot, grandchild-slot) pair has not                    yet been processed                -    create a constraint “tAsBtCsD”, where A is a                    child-slot, B is a grandchild-slot of child-slot A,                    C is a child-slot, and D is a grandchild-slot of                    child-slot C. This constraint will limit the use of                    the path between the grandchild-slots.    -   declare a constraint “totlen” to define a total length variable    -   for each slot-net X        -   for each path Y in the route for the slot-net            -   for each propagation Z of that path                -   declare a constraint, “nXeYpZ”, to force the LP                    solver to choose the same propagation for an                    identical path in both of its incident child-slots        -   for each child-slot upon which the route of the current            slot-net is incident            -   declare a constraint, “nXtY”, where Y is the number of                the child-slot. This is destined to select one                configuration per slot-net in each child-slot-   //finished declaring constraints, now turn to variables    -   for each slot-net        -   for each child-slot upon which the route of the current            slot-net is incident            -   identify all configurations of slot-net in                child-slot//done according to process 7900            -   for each generated configuration                -   create variable “nAtBeCpD” where A,B,C,D are                    integers identifying the net, slot, path and                    propagation, respectively of the config                -   for each path in the config                -    if propagation for the path is “unuseable”, add a                    penalty to the config cost//where unuseability                    determined based on the congestion estimate obtained                    from the estimates produced by processes 7700 and                    7800                -    declare nAtBeCpD to be present in constraint                    “nAeCpD” with factor 1.0 if B is the lesser index of                    the 2 child-slots incident to this path, −1.0                    otherwise                -    for each sub-path in the propagation of the path                -    retrieve the 2 (child-slot, grandchild-slot) pairs                    that serve as endpoints of the sub-path                -    declare nAtBeCpD to be present in the constraint                    corresponding to this pair of (child-slot,                    grandchild-slot)s with factor 0.5            -   declare nAtBeCpD to be present in constraint “nAtB” with                factor 1.0            -   declare nAtBeCpD to be present in constraint “totLen”                with factor equal to the config cost, stored in the                configuration's data structure, plus any penalty    -   create variable “t1” to represent the total length of the        configs selected    -   declare t1 to be present in constraint “totLen” with factor −1.0    -   declare t1 to be present in the objective function with factor        1.0    -   set the rhs of constraint “totLen”=0.0    -   for each path of the slot        -   for each propagation of the path            -   retrieve all paths comprising the propagation            -   for each path of the propagation                -   retrieve the (child-slot, grandchild-slot) pairs                    that serve as endpoints of the path (a child-slot,                    grandchild-slot pair may occur in more than one                    propagation)                -   if this (child-slot, grandchild-slot) pair has not                    yet been processed                -    create a constraint “tAsBtCsD”, where A is a                    child-slot, B is a grandchild-slot of child-slot A,                    C is a child-slot, and D is a grandchild-slot of                    child-slot C. This constraint will limit the use of                    the path between the grandchild-slots.                -    set the rhs of constraint “tAsBtCsD” to the default                    capacity of the propagation-path plus the local                    variable “slack” value minus the sum of the estimate                    path use of the propagation and the blocked capacity                    of the propagation path//where the estimated path                    use was computed by process 7800 and the blocked                    capacity was computed by process 7700    -   for each slot-net A        -   for each path B in the route of the slot-net            -   for each propagation C of that path                -   set rhs of constraint “nAeBpC” to 0.0.        -   for each child-slot B upon which the route for this slot-net            is incident            -   set the rhs of constraint “nAtB” equal to 1.0    -   solve the LP    -   if a solution was found, break out of while loop; otherwise set        slack=slack+1 and start again

As indicated above, the second-to-last line of the formulation tells (at7620) the LP solver to solve the problem. The LP solver then tries tosolve this problem. Each time the LP solver fails to solve this problem,the formulation above increments the slack value until the LP solver isable to solve the problem.

The LP solver returns a real-number optimal solution. The process 7600then converts this solution to an integer LP (“ILP”) solution. Someembodiments use randomized rounding to perform this conversion, asdescribed above. One of ordinary skill will understand that, instead ofusing an LP solver to generate an LP solution and converting the LPsolution into an ILP solution, other embodiments use an ILP solver forthe propagator to generate an ILP solution.

e. Follow-Up Propagation

When the current slot's level is at least two levels above the leaflevel, the process 7600 adds the propagation paths that it identified at7625 to the follow-up propagation list for the next lower recursionlevel. FIG. 65 illustrates one example of propagation paths that can beadded to the follow-up propagation list. As mentioned above, this figureillustrates a net that has actual pins 6525 in slots 0 and 9. Theselected route for this net uses paths P17 and P24 that traverse childslot 5 to connect child slots 0 and 9.

FIG. 65 illustrates that the path P24 is propagated into child slots 0and 5 by paths 6510 and 6515, while the path P17 is propagated intochild slots 5 and 9 by path 6520. The propagation path 6510 is betweenthe child slot 7 of the current slot's child slot 0 and the child slot 8of the current slot's child slot 1. The propagation path 6515 is betweenthe child slot 13 of the current slot's child slot 1 and the child slot2 of the current slot's child slot 5. The propagation path 6520 isbetween the child slot 14 of the current slot's child slot 5 and thechild slot 2 of the current slot's child slot 9. FIG. 65 illustratesfive virtual pins that have been added to the slots of child slots 1, 5,and 9.

When the current slot's level is at least two levels above the leaflevel, the process 7600 adds the propagation paths 6510, 6515, and 6520to the follow-up propagation list for the next lower recursion level.The propagator will then use this list when performing follow-uppropagation for a child slot of the current slot. This propagationoperation propagates the paths on the follow-up propagation list onelevel further down.

FIG. 81 illustrates a process 8100 for performing follow-up propagationfor the current slot when the current slot is below the top-level slotbut above the leaf-level slot. By definition, such a current slot is achild slot of a previous parent slot. As shown in FIG. 81, the process8100 initially determines (at 8105) either (1) whether the follow-uppropagation list includes any path that has at least one anchor, or (2)whether the current slot is the last slot of the current level and thefollow-up propagation list still includes one or more paths.

If the process identifies no paths at 8105, the process ends. Otherwise,the process 8100 selects (at 8110) one of the identified paths, andremoves this path from the follow-up propagation list. Next, the processcosts (at 8115) each propagation permutation of the selected path. Thecost of each propagation permutation includes the cost of itspropagation path(s) plus the routing cost of the pin configurations inthe two or three child slots that the propagation permutation traverses.

Next, the process selects (at 8120) the lowest cost propagationpermutation. The selected propagation permutation includes one and insome cases two propagation paths. For instance, in the exampleillustrated in FIG. 65, the propagation of path P24 resulted in twopropagation paths 6510 and 6515, while the propagation of path 17resulted in one propagation path 6520.

For each propagation path, some embodiments maintain a slot-pair record,which stores the identity of the child slots that the path joins and theremaining capacity of the path. Accordingly, at 8125, the processdetermines whether a slot-pair data structure exists for eachpropagation path that forms the propagation permutation selected at8120. When such a structure does not exist for a propagation path of theselected propagation permutation, the process (at 8125) creates a slotpair structure for the path, stores in the structure the identity of thechild slots that the path traverses, and initializes the capacity fieldof the structure. The initialized capacity for a propagation path is thedefault capacity of the path minus any blockages on the path. When aslot-pair structure already exists for a propagation path of theselected propagation permutation, the process identifies (at 8125) thepath's remaining capacity from this structure.

At 8130, the process determines whether the selected propagationpermutation can be embedded in the current slot's child slots. In otherwords, the process determines whether the propagation path or paths thatform the selected propagation permutation have a remaining capacitygreater than a threshold value. In some embodiments, the threshold valueis 0. In these embodiments, the selected propagation permutation isembeddable when all the paths that form it have a remaining capacitygreater than zero.

If the process determines that the selected propagation permutationcannot be to embedded, it determines (at 8135) whether there areadditional propagation permutations for the path selected at 8120. Ifso, the process selects (at 8140) the next cheapest propagationpermutation and then transitions to 8125.

When the process determines (at 8135) that there are no additionalpropagation permutations to examine, the process embeds (at 8160) thebest propagation permutation that it examined at 8130. This embeddingmight entail setting virtual pins in the pin distributions of affectedchild slots (i.e., setting virtual pins in the current slot's grandchildslots that the selected propagation permutation's path or pathstraverse). One example of setting such virtual pins is illustrated inFIG. 82. This figure illustrates (1) a path 6510 from the follow-up pathlist that is propagated into slot 11 of child slot 7 by path 8205, and(2) a virtual pin 8210 that has been set in slot 11 to account for thispropagation. This figure also illustrates that the path 6510 has beenpropagated along path 8215 into slot 12 of child slot 4 and slot 1 ofchild slot 8 of the slot adjacent to the current slot 8220. This figurealso illustrates two virtual pins that have been set in slots 12 and 1of the adjacent slot's child slots 4 and 8.

At 8160, the process also updates the available capacity of thepropagation path or paths used by the embedded propagation permutation.As mentioned above, the available capacity of a propagation path can becomputed as the default capacity of the path minus the sum of itsblocked capacity and its path use estimate, where the blocked and usevalues are computed according to the processes 7700 and 7800. Someembodiments might not factor the path use estimate computed by usingprocess 7800 in the available capacity of each propagation path.

When the current slot's level is at least two levels above the leaflevel, the process (at 8160) also adds the embedded propagation path(s)to the follow-up propagation list for the next lower recursion level.From 8160, the process transitions to 8150, which will be describedbelow.

When the process determines (at 8130) that a selected propagationpermutation can be embedded, it embeds (at 8145) the propagationpermutation selected at 8120 or 8140. This embedding might entailsetting virtual pins in the pin distributions of affected child slots(i.e., setting virtual pins in the current slot's grandchild slots thatthe selected propagation permutation's path or paths traverse). At 8145,the process also updates the available capacity of the propagation pathor paths used by the embedded propagation permutation. When the currentslot's level is at least two levels above the leaf level, the process(at 8145) also adds the embedded propagation path(s) to the follow-uppropagation list for the next lower recursion level. From 8145, theprocess transitions to 8150.

At 8150, the process determines whether it has examined all the pathsthat it identified at 8105. If not, the process returns to 8110 toselect another unexamined path that it identified at 8105. If so, theprocess ends.

2. Sequential Propagator

Some embodiments of the invention use a sequential propagation approachto identify how to propagate the routes specified by the solver into thecurrent slot's child slots. Some of these embodiments use such anapproach when they use the diagonal propagation model of FIG. 63.

FIG. 83 illustrates one a sequential-propagation process that is used insome embodiments. As shown in this figure, this process starts bycomputing (at 8305) the available capacity of each propagation betweenthe child slots of the current slot's child slots. The availablecapacity of each propagation path equals the default capacity of thepath minus its blocked capacity plus its path use estimate. As mentionedabove, processes 7700 and 7800 can be used to compute the blocked andpath use values. Some embodiments might not factor the path use estimatecomputed by using process 7800 in the available capacity of eachpropagation path.

After computing the available propagation capacities, the processselects (at 8310) a slot-net in the current slot. It then retrieves (at8315) the route for the selected slot-net. At 8325, the process thenselects a path with the most number of anchors. As mentioned above, someembodiments define an anchor as a pin in either child slot upon whichthe path is incident. In these embodiments, a path has at most twoanchors. Other embodiments might define anchor as the number of pins inthe slots of a child slot; under such an approach, a path can have up to32 anchors, when it has 16 pins in the 16 slots of each child slot.

Next, the process costs (at 8330) each propagation permutations of theselected path. The cost of each propagation permutation includes thecost of the permutation's propagation path(s) plus the routing cost ofthe pin configurations in the two or three child slots that thepropagation permutation traverses.

Next, the process selects (at 8335) the lowest cost propagationpermutation. The selected propagation permutation includes one and insome cases two propagation paths. For instance, in the exampleillustrated in FIG. 65, the propagation of path P24 resulted in twopropagation paths 6510 and 6515, while the propagation of path 17resulted in one propagation path 6520.

At 8340, the process determines whether the selected propagationpermutation can be embedded in the current slot's child slots. In otherwords, the process determines whether embedding the selected propagationpermutation will cause any propagation path for this permutation to beover congested.

If the process determines that the selected propagation permutationcannot be embedded, it determines (at 8345) whether there are additionalpropagation permutations for the path selected at 8325. If so, theprocess selects (at 8350) the next cheapest propagation permutation andreturns to 8340 to determine whether the newly-selected permutation canbe embedded.

When the process determines (at 8345) that there are no additionalpropagation permutations to examine, the process embeds (at 8365) thebest propagation permutation that it encountered at 8340. This embeddingmight entail setting virtual pins in the pin distributions of affectedchild slots (i.e., setting virtual pins in the current slot's grandchildslots that the selected propagation permutation's path or pathstraverse). When the current slot's level is at least two levels abovethe leaf level, this embedding also entails adding the propagation pathsused by the selected propagation permutation to the follow-uppropagation list for the next lower recursion level. At 8365, theprocess also updates the available capacity of the propagation paths ofthe embedded propagation permutation. From 8365, the process transitionsto 8360, which will be described below.

When the process determines (at 8340) that a selected propagationpermutation can be embedded, it embeds (at 8355) the selectedpropagation permutation. This embedding might entail setting virtualpins in the pin distributions of affected child slots (i.e., settingvirtual pins in the current slot's grandchild slots that the selectedpropagation permutation's path or paths traverse). When the currentslot's level is at least two levels above the leaf level, this embeddingalso entails adding the propagation paths used by the selectedpropagation permutation to the follow-up propagation list for the nextlower recursion level. At 8355, the process also updates the availablecapacity of the propagation paths of the embedded propagationpermutation. From 8355, the process transitions to 8360.

At 8360, the process determines whether it has examined all the paths ofthe selected slot-net's route. If not, the process returns to 8325 toselect another path of this route. If so, the process determines (at8370) whether it has examined all the slot-nets in the current slot.

If the process has not examined all the slot-nets in the current slot,the process returns to 8310 to select another slot-net. Otherwise, theprocess transitions to 8375. When the current slot's level is after thetop level but before the leaf level, the sequential propagator thenperforms (at 8375) a follow-up propagation operation. This operationpropagates the routing paths specified by the propagator at the previousrouting level one level further down. When the current slot's level isthe level immediately before the leaf level (i.e., when the current slotis a grandparent of Gcells), the sequential propagator calls (at 8380)the saver to link to the dBNets the path data structures of anypropagation path embedded at 8355, 8365, and 8375. The process thenends.

VII. The Computer System

FIG. 84 presents a computer system with which one embodiment of thepresent invention is implemented. Computer system 8400 includes a bus8405, a processor 8410, a system memory 8415, a read-only memory 8420, apermanent storage device 8425, input devices 8430, and output devices8435.

The bus 8405 collectively represents all system, peripheral, and chipsetbuses that communicatively connect the numerous internal devices of thecomputer system 8400. For instance, the bus 8405 communicativelyconnects the processor 8410 with the read-only memory 8420, the systemmemory 8415, and the permanent storage device 8425.

From these various memory units, the processor 8410 retrievesinstructions to execute and data to process in order to execute theprocesses of the invention. The read-only-memory (ROM) 8420 storesstatic data and instructions that are needed by the processor 8410 andother modules of the computer system. The permanent storage device 8425,on the other hand, is read-and-write memory device. This device is anon-volatile memory unit that stores instruction and data even when thecomputer system 8400 is off. Some embodiments of the invention use amass-storage device (such as a magnetic or optical disk and itscorresponding disk drive) as the permanent storage device 8425. Otherembodiments use a removable storage device (such as a floppy disk orzip® disk, and its corresponding disk drive) as the permanent storagedevice.

Like the permanent storage device 8425, the system memory 8415 is aread-and-write memory device. However, unlike storage device 8425, thesystem memory is a volatile read-and-write memory, such as a randomaccess memory. The system memory stores some of the instructions anddata that the processor needs at runtime. In some embodiments, theinvention's processes are stored in the system memory 8415, thepermanent storage device 8425, and/or the read-only memory 8420.

The bus 105 also connects to the input and output devices 8430 and 8435.The input devices enable the user to communicate information and selectcommands to the computer system. The input devices 8430 includealphanumeric keyboards and cursor-controllers.

The output devices 8435 display images generated by the computer system.For instance, these devices display IC design layouts. The outputdevices include printers and display devices, such as cathode ray tubes(CRT) or liquid crystal displays (LCD).

Finally, as shown in FIG. 84, bus 8405 also couples computer 8400 to anetwork 8465 through a network adapter (not shown). In this manner, thecomputer can be a part of a network of computers (such as a local areanetwork (“LAN”), a wide area network (“WAN”), or an Intranet) or anetwork of networks (such as the Internet).

Any or all of the components of computer system 8400 may be used inconjunction with the invention. However, one of ordinary skill in theart would appreciate that any other system configuration may also beused in conjunction with the present invention.

While the invention has been described with reference to numerousspecific details, one of ordinary skill in the art will recognize thatthe invention can be embodied in other specific forms without departingfrom the spirit of the invention. For instance, several embodiments weredescribed above by reference to a hierarchical router, one of ordinaryskill will realize that other embodiments of the invention areimplemented with other router types, such as maze routers.

Also, even though several embodiments were described by reference to anLP-problem formulation, one of ordinary skill will realize that theseembodiments can be practiced by applications that do not utilize an LPsolver. The above-described track sharing constraints provide one suchexample. Any type of router can account for these sharing constraints indetermining whether to embed routes.

In addition, other embodiments might use different set of partitioninglines to divide the circuit layout. For example, some embodiments mightuse partitioning grids that define different-shaped and/ordifferent-sized sub-regions than the sub-regions defined by the 4×4 gridillustrated in FIG. 5. Thus, one of ordinary skill in the art wouldunderstand that the invention is not to be limited by the foregoingillustrative details, but rather is to be defined by the appendedclaims.

We claim:
 1. For a router that uses a set of partitioning lines topartition a region of a design layout into a plurality of sub-regions, amethod of pre-computing routes for nets, wherein a sub-regionconfiguration is a set of sub-regions, and different sub-regionconfigurations represent different sets of sub-regions, the methodcomprising: a) identifying groups of related sub-region configurations,wherein each group comprises different first and second sub-regionconfigurations; b) for each group: i) identifying and storing a base setof routes for the first configuration in the group, wherein each routein the base set connects the sub-regions of the first configuration; ii)storing a set of indicia specifying how to generate a related set ofroutes for the second configuration from the base set of routes.
 2. Themethod of claim 1, wherein each group of sub-region configurationscomprises a plurality of symmetrical sub-region configurations, each ofwhich is related to the group's first configuration based on aparticular symmetrical relationship.
 3. The method of claim 2, whereinthe plurality of symmetrical sub-region configurations comprises thesecond sub-region configuration.
 4. The method of claim 2, wherein thestored set of indicia for each particular symmetrical configuration ofeach particular group specifies a particular transformation of theparticular group's base set of routes to the set of routes for theparticular symmetrical configuration, wherein each particularsymmetrical configuration's specified transformation is based on theparticular configuration's symmetrical relationship to the particulargroup's base configuration.
 5. The method of claim 4, wherein thetransformation of at least one particular symmetrical configuration ofeach group specifies that the group's base set of routes has to berotated about an origin by a particular angle to generate the at leastone particular symmetrical configuration's set of routes.
 6. The methodof claim 5, wherein the transformation of the at least one particularsymmetrical configuration of each group further specifies that thegroup's base set of routes has to be flipped about an axis to generatethe particular symmetrical configuration's set of routes.
 7. The methodof claim 4, wherein the transformation of at least one particularsymmetrical configuration of each group specifies that the group's baseset of routes has to be flipped about an axis to generate the particularsymmetrical configuration's set of routes.
 8. The method of claim 1,wherein the related set of routes is different from the base set ofroutes.
 9. The method of claim 1, wherein the set of indicia identifiesa specific symmetrical relationship between the first and secondconfigurations.
 10. For an electronic design automation (“EDA”) routerthat routes nets within a region of an integrated-circuit layout, amethod of pre-computing routes, the method comprising: a) defining a setof partitioning lines for partitioning the region into a plurality ofsub-regions, wherein different sets of sub-regions represent differentsub-region configurations; b) for a first sub-region configuration,identifying a first set of routes, wherein each route in the first setconnects the first set of sub-regions; c) identifying a secondsub-region configuration that is symmetrical to the first sub-regionconfiguration; d) storing the first set of routes in a storagestructure; e) storing a set of indicia specifying how to generate asecond set of routes for the second sub-region configuration from thefirst set of routes stored for the first sub-region configuration. 11.The method of claim 10, wherein the stored set of indicia specifies asymmetrical relationship between the first and second sub-regionconfigurations.
 12. The method of claim 10, wherein the stored set ofindicia specifies that each route in the first set of routes needs to berotated a particular angle to generate a route in the second set ofroutes.
 13. The method of claim 10, wherein the stored set of indiciaspecifies that each route in the first set of routes needs to be flippedabout an axis to generate a route in the second set of routes.
 14. Themethod of claim 10 further comprising: identifying other sub-regionconfigurations that are symmetrical to the first sub-regionconfiguration; and for each other sub-region configuration, storing aset of indicia specifying how to generate a set of routes for the othersub-region configuration from the first set of routes stored for thefirst sub-region configuration.
 15. The method of claim 10, whereinstoring the first set of routes comprises: a) determining whether eachroute in the first set is previously stored in the storage structure; b)when a particular route in the first set is previously stored in thestorage structure, associating the stored particular route with thefirst and second sub-region configurations; and c) when a particularroute in the first set is not stored in the storage structure, storingthe particular route in the storage structure, and associating thestored particular route with the first and second sub-regionconfigurations.
 16. The method of claim 15, wherein associating thefirst and second set of sub-region configurations with each route in thefirst set of routes comprises: for the first and second set ofsub-region configurations, storing a set of references to routes,wherein each reference in the set of references refers to one route inthe first set of routes.
 17. The method of claim 10, wherein the firstset of routes includes only one route.
 18. The method of claim 10,wherein the first set of routes includes more than one route.
 19. For arouter that uses a set of partitioning lines to partition a region of adesign layout into a plurality of sub-regions, a computer medium havinga computer program that pre-computes routes for nets, wherein asub-region configuration is a set of sub-regions, and differentsub-region configurations represent different sets of sub-regions, thecomputer program comprising: a) a first set of instructions foridentifying groups of related sub-region configurations, wherein eachgroup comprises different first and second sub-region configurations; b)a second set of instructions for, for each group: i) identifying andstoring a base set of routes for the first configuration in the group,wherein each route in the base set connects the sub-regions of the firstconfiguration; ii) storing a set of indicia specifying how to generate arelated set of routes for the second configuration from the base set ofroutes.
 20. The computer medium of claim 19, wherein each group ofsub-region configurations comprises a plurality of symmetricalsub-region configurations, each of which is related to the firstconfiguration based on a particular symmetrical relationship.